El código del ejemplo lo pueden descargar aquí
domingo, 23 de octubre de 2011
Videotutorial Flex y Bison
Ejemplo de la estructura de los archivos de flex y bison y recuperación de errores sintácticos.
El código del ejemplo lo pueden descargar aquí
El código del ejemplo lo pueden descargar aquí
domingo, 14 de agosto de 2011
Ejemplo de Estados en JLex
Se modificara el archivo de JLex para manejar estados. Los estados que maejaremos son
Nuestro codigo JLex como quedara lo pueden descargar aqui
- YYINITIAL: Que es el estado creado por defecto en JLex
- COMENTARIO: Que es el estado que manejara y reconocera nuestros comentarios.
El tipo de comentario que reconocera es de la forma:
/* Este es un comentario
De varias lineas
*/
Nuestro codigo JLex como quedara lo pueden descargar aqui
Ejemplo JLex sin usar Cup en Ubuntu
En este ejemplo se explica como se realiza un analisis lexico con JLex sin usar el analizador sintactico en ubuntu, para esto se supone que ya instalaron y configuraron las herramientas.
Instalación JLex y Cup en Ubuntu
En el siguiente video se muestra como instalar las herramientas de JLex y Cup para realizar un analisis lexico, semantico y sintactico en Java. Luego se muestra con un ejemplo que todas las herramientas este correctamente instaladas y configuradas.
Algo que no explica en el video es que en Ubunto (No se si en las otras distribuciones es igual), cada vez que se reinicia el sistema hay que configurar nuevamente las variables de entorno de JLex y Cup, para evitar esto, debemos de agragar la linea export CLASSPATH=.:/usr/share/java/JLex.jar:/usr/share/java/cup.jar al final de del archivo .bashrc, para hacer esto, desde una consola ejecutamos el siguiente comando
echo "export CLASSPATH=.:/usr/share/java/JLex.jar:/usr/share/java/cup.jar" | tee -a ~/.bashrc
Y listo, las variables de entorno de JLex y Cup no se borraran cada vez que reiniciamos el sistema.
Algo que no explica en el video es que en Ubunto (No se si en las otras distribuciones es igual), cada vez que se reinicia el sistema hay que configurar nuevamente las variables de entorno de JLex y Cup, para evitar esto, debemos de agragar la linea export CLASSPATH=.:/usr/share/java/JLex.jar:/usr/share/java/cup.jar al final de del archivo .bashrc, para hacer esto, desde una consola ejecutamos el siguiente comando
echo "export CLASSPATH=.:/usr/share/java/JLex.jar:/usr/share/java/cup.jar" | tee -a ~/.bashrc
Y listo, las variables de entorno de JLex y Cup no se borraran cada vez que reiniciamos el sistema.
martes, 19 de julio de 2011
Ontologia eSalud
En el curso de Inteligencia Artificial 1 impartido por Javier Gramajo Lopez, he estado trabajando en un proyecto sobre ontologías, que son búsquedas semánticas que es parte de la web 3.0, es una tecnología relativamente nueva en el cual se reemplaza una base de datos con álgebra relacional, con una relación semántica.
Mi tema de ontología se centra en búsquedas relacionadas con eSalud que son los bienes y servicios que prestan centros de salud a distancia desde un punto remoto, también la ontoligia hace búsquedas de farmacias, medicamentos, especialistas y educación sobre eSalud.
Este es solo el primer prototipo, no esta poblada de todos los datos existentes, pero seguiré trabajando en esta tecnología mejorando las búsquedas y poblando.
A continuación muestro la documentación, explicando con mas claridad lo que son las Ontologias, eSalud y hablando sobre este prototipo.
Ontologia eSalud
El prototipo lo pueden encontrar en: http://esaludusac.comli.com
Mi tema de ontología se centra en búsquedas relacionadas con eSalud que son los bienes y servicios que prestan centros de salud a distancia desde un punto remoto, también la ontoligia hace búsquedas de farmacias, medicamentos, especialistas y educación sobre eSalud.
Este es solo el primer prototipo, no esta poblada de todos los datos existentes, pero seguiré trabajando en esta tecnología mejorando las búsquedas y poblando.
A continuación muestro la documentación, explicando con mas claridad lo que son las Ontologias, eSalud y hablando sobre este prototipo.
Ontologia eSalud
El prototipo lo pueden encontrar en: http://esaludusac.comli.com
domingo, 29 de mayo de 2011
jueves, 12 de mayo de 2011
Como unir varios archivos de felx y bison en un mismo proyecto
Supongamos que en un proyecto necesitan analizar varios archivos uno tiene extensión .conf, que tiene la estructura de su tabla de símbolos, otro tiene extensión .sql que trae instrucciones para insertar datos y varios archivos con extensión .dbf que tienen los datos ya insertados. Y todos estos archivos deben de ser analizados con flex y bison.
Si ya han creado todos sus scanners y parsers, uno para el archivo con extensión .conf, uno para el .sql, otro para los .dbf, ahora como llamarlos desde la aplicación? Si todos los archivos generados los tenemos con el nombre parser y si los agregan a su proyecto les darán errores. Tienen que hacer varias cosas antes de integrar más de un archivos felx y bison en un mismo proyecto, para eso sigan los siguientes pasos:
1) Es mejor tener todos los analizadores en carpetas diferentes, es decir creas una carpeta conf y en ella guardar los archivos .l y .y. para analizar el .conf. En otra carpeta, por ejemplo sql, guardas otros archivos .l y .y para analizar los .sql. Esto en realidad no es necesario, solo es para tener una estructura ordenada de nuestro proyecto.
2) Van a nombrar a cada archivo .l y .y diferentes. por ejemplo para analizar el .conf pueden llamarlos lexico1.l y sintactico1.y y para el .sql poden llamarlo lexico2.l y sintactico2.y. Esto es un ejemplo, poden llamarlos como ustedes quieran, pero tomen en cuenta que son nombres diferentes.
3) En sus archivos .l y .y existen funciones como yylval, yytext, yyparse, etc. deben de cambiarle el "yy" a cada uno de ellos, por ejemplo yy1lval, yy1text, yy1parser, etc. esto para que no exista conflicto luego de juntar los dos analizadores.
4) Si usan una variable por ejemplo linea o archivo en su lexico1.l o sintactico1.y , y usan estas mismas variables en los archivos lexico2 y sintactico2, deben de cambiarlo, también por conflictos de que existen 2 variables declaradas en diferentes archivos entonces deben de llamarlos de diferente forma, por ejemplo linea1 y archivo1 en su primer analizador y linea2 y archivo2 en el otro. (Nota: Existe conflicto solo cuando usan extern para hacer referencia a una variable que está en otro archivo).
5) Ahora para compilar cada uno de estos archivos lo haces con los mismos comandos, pero las salidas van a nombrarlas de diferente manera y agregar el parámetro –P y –p en flex y bison respectivamente.
Para el .conf
> flex -P yy1 --header-file=scanner1.h -o scanner1.cpp lexico1.l
> bison -p yy1 – o parser1.cpp --defines=parser1.h sintactico1.y
Para el .sql
> flex -P yy2 --header-file=scanner2.h -o scanner2.cpp lexico2.l
> bison -p yy2 – o parser2.cpp --defines=parser2.h sintactico2.y
Por último, cuando quieran usar los diferentes parser lo haces de la siguiente forma
Para el .conf
yy1in=fopen( "entrada.conf","rt");
if (!yyin)
cout<<"error al abrir"<<endl;
yy1parse();
Para el .sql
yy2in=fopen( "entrada.sql","rt");
if (!yy2in)
cout<<"error al abrir"<<endl;
yy2parse();
Nota: En resumen, al compilar usan los parámetros -P yy1 en flex y -p yy1 en bison, esto hace que todas las funciones como yylval, yytext, yyparser, etc, cambie el "yy" por el "yy1" que esta en comando para compilar, entonces al generar los archivos las funciones se llamen yy1lval, yy1text, yy1parser. Por eso es que cambiamos en el paso tres el nombre de las funciones que inician con yy en los archivos lexico.l y sintactico.y. Y de esta forma evitan que se dupliquen las funciones y que exista un conflicto y les de error en su proyecto.
lunes, 9 de mayo de 2011
Ejemplo Programa con LeJOS para el Lego NXT Mindstorms
Realizaremos un programa muy sencillo para familiarizarnos con java y el robot de lego, primero lo que necesitamos es “Lejos” para poder compilar nuestro programa en lenguaje java y poder subírselo al robot.
Ya que lo descargaron, ejecútenlo e instalen el programa, son unos pocos pasos y muy fáciles de instalar.
Nuestro primer ejemplo será muy sencillo, usaremos los sensores ultrasónico, táctil y de sonido y los motores. El robot empezará a caminar, si está en marcha y hacemos un ruido como un silbido o una palmada el robot se detiene, en caso contrario si el robot esta en reposo y hacemos un ruido el robot empezara a moverse. Si el robot se acerca a un objeto, se detendrá y si presionamos el sensor táctil entonces girara. El código para esto es el siguiente:
import lejos.nxt.*; public class Practica1 { LCD.drawString("Iniciando",1,3); //Instanciamos los puertos para casa sensor del lego UltrasonicSensor sonic = new UltrasonicSensor(SensorPort.S1); TouchSensor touch = new TouchSensor(SensorPort.S2); SoundSensor sound = new SoundSensor(SensorPort.S3); // Se repite hasta que precionemos el boton escape //Sonido if (sound.readValue()>86){ if (Motor.A.isMoving()){ Motor.B.stop(); Motor.A.stop(); } else{ Motor.A.forward(); Motor.B.forward(); } } //Distancia LCD.drawString(" "+sonic.getDistance()+" ",0,3); LCD.clear(); if (sonic.getDistance()<21&&Motor.A.isMoving()&& Motor.B.isMoving()) { Motor.A.stop(); Motor.B.stop(); } //Tacto if(touch.isPressed()) { Motor.B.stop(); Motor.A.rotate(800); } } } }
El archivo lo guardamos con el nombre Practica1.java. Como pueden ver es un código muy fácil de entender, para compilar abran una consola y deberán de usar el siguiente comando
nxjc Practica1.java
Para subirlo al robot usan el comando
nxj Practica1
Existen mas funciones para poder mover el motor pueden ver ejemplos y más explicaciones sobre estas funciones desde su página oficial, Pronto estaré haciendo otros ejemplos mucho mas complejos.
En el siguiente link esta el video de como actúa el robot al ejecutar el programa anterior.
viernes, 22 de abril de 2011
lunes, 11 de abril de 2011
Ejemplo Flex y Bison
Vamos a realizar un ejemplo de una calculadora sencilla que reconocerá las principales operaciones aritmética (+,-,* y /).
Abrimos un editor de texto y pegamos el siguiente código que será nuestro scanner
/*****************
Definiciones
Se colocan las cabeceras, variables y expresiones regulares
********************/
%{
#include <stdio.h>
#include <stdlib.h>
#include "sintactico.tab.h"
int linea=0;
%}
/*
Creamos todas las expresiones regulares
Creamos la definición llamada DIGITO, podemos acceder esta definición
usando {DIGITO}*/
DIGITO [0-9]
NUMERO {DIGITO}+("."{DIGITO}+)?
%%
/***************
Reglas
*****************/
/* Creamos las reglas que reconocerán las cadenas que acepte
Nuestro scanner y retornaremos el token a bison con la
funcion return. */
{NUMERO} {yylval.real=atof(yytext); return(NUMERO);}
"=" {return(IGUAL);}
"+" {return(MAS);}
"-" {return(MENOS);}
";" {return(PTOCOMA);}
"*" {return(POR);}
"/" {return(DIV);}
"(" {return(PAA);}
")" {return(PAC);}
"\n" {linea++;}
[\t\r\f] {}
" " {}
/* Si en nuestra entrada tiene algún caracter que no pertenece a
las reglas anteriores, se genera un error léxico */
. {printf("Error lexico en linea %d",linea);}
%%
/*
Código de Usuario
Aquí podemos realizar otras funciones, como por ejemplo ingresar
símbolos a nuestra tabal de símbolos o cualquier otra accione
del usuario.
Todo lo que el usuario coloque en esta sección se copiara al
archvi lex.yy.c tal y como esta.
*/
Guardamos el archivo como lexico.l. Luego creamos un nuevo archivo y colocamos el siguiente código.
%{
/********************
Declaraciones en C
**********************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
extern int yylex(void);
extern char *yytext;
extern int linea;
extern FILE *yyin;
void yyerror(char *s);
%}
/************************
Declaraciones de Bison
*************************/
/* Especifica la coleccion completa de tipos de datos para poder usar
varios tipos de datos en los terminales y no terminales*/
%union
{
float real;
}
/* Indica la produccion con la que inicia nuestra gramatica*/
%start Exp_l
/* Especificacion de termines, podemos especificar tambien su tipo */
%token <real> NUMERO
%token MAS
%token MENOS
%token IGUAL
%token PTOCOMA
%token POR
%token DIV
%token PAA
%token PAC
/* No Terminales, que tambien podemos especificar su tipo */
%type <real> Exp
%type <real> Calc
%type <real> Exp_l
/* Definimos las precedencias de menor a mayor */
%left MAS MENOS
%left POR DIV
%%
/**********************
Reglas Gramaticales
***********************/
Exp_l: Exp_l Calc
|Calc
;
Calc : Exp PTOCOMA {printf ("%4.1f\n",$1)}
;
/* con el símbolo de $$ asignamos el valor semántico de toda
la acción de la derecha y se la asignamos al no terminal de
la izquierda, en la siguiente regla, se la asigna a Exp.
Para poder acceder al valor de los terminales y no terminales del lado
derecho usamos el símbolo $ y le concatenamos un numero que representa
la posición en la que se encuentra es decir si tenemos
A --> B NUMERO C
Si queremos usar le valor que tiene el no terminal B usamos $1, si queremos
usar el valor que tiene NUMERO usamos $2 y así sucesivamente.
*/
Exp : NUMERO {$$=$1;}
|Exp MAS Exp {$$=$1+$3;}
|Exp MENOS Exp {$$=$1-$3;}
|Exp POR Exp {$$=$1*$3;}
|Exp DIV Exp {$$=$1/$3;}
|PAA Exp PAC {$$=$2;}
;
%%
/********************
Codigo C Adicional
**********************/
void yyerror(char *s)
{
printf("Error sintactico %s",s);
}
int main(int argc,char **argv)
{
if (argc>1)
yyin=fopen(argv[1],"rt");
else
yyin=stdin;
yyparse();
return 0;
}
Guardamos este archivo con el nombre sintáctico.y y con eso ya tenemos nuestro scanner y nuestro parser terminado. Para compilar estos archivos usamos los comandos
Compilando sintactico.y
~> bison -d sintactico.y
El parámetro –d, crea el fichero t.tab.h, que contiene los identificadores de los tokens de bison usados por flex
Compilando lexico.l
~> flex lexico.l
Compilando arhivos generados y crear ejecutable
~> cc lex.yy.c sintactico.tab.c -o analizador -lfl -lm
Esto nos genera un ejecutable llamado analizador.
Muchas veces necesitamos modificar nuestro archivo sintáctico.y o lexico.l y tenemos que compilar todo cada vez que hacemos un cambio, para no estar escribiendo los comandos cada vez que realizamos un cambio, crearemos un script, que al ejecutarlo realizara todos los comandos de compilación. Para eso creamos un nuevo archivo en blanco y escribimos
#!/bin/bash
bison -d sintactico.y
flex lexico.l
cc lex.yy.c sintactico.tab.c -o analizador -lfl –lm
Guardamos este archivo con cualquier nombre, por ejemplo compilar.sh. Ahora cambiaremos las propiedades de este archivo para poder ejecutar. Le damos clic derecho sobre este archivo y en la pestaña permisos elegimos la opción de “Permitir ejecutar el archivo como un programa”, cerramos esa ventana.
Para poder compilar, desde consola nos ubicamos donde se encuentra este archivo .sh y escribimos
./compilar.sh
Esto nos genera nuestro ejecutable que podemos correr para poder probar nuestra calculadora. Para ejecutar este ejemplo usamos el comando
./analizador
Ingresamos algunas expresiones y el resultado que obtenemos es:
Instalar Flex y Bison en Linux
Para realizar un análisis léxico y sintáctico en c usaremos las herramientas de Flex y Bison. Para instalar podemos hacerlo de varias formas, dependiendo en la distribución de Linux que usemos los comandos o la aplicación cambian un poco, pero el proceso es básicamente el mismo. Aquí trabajaremos con OpenSuse 11.3 y para instalarlo podemos usar el modo grafico, abren Yast y en la sección de Instalar/Desinstalar software pero podemos usar la consola que para mí es mucho más fácil y cómoda.
Primero instalaremos Flex, para hacerlo abrimos una terminal y escribimos:
~> sudo zypper in flex
Les pedirá el password del usuario root, la ingresan e iniciara la instalación.
Par instalar Bison el proceso es el mismo escribimos en la terminal
~> sudo zypper in bison
Y listos, flex y bison instalados.
Para los que utilicen Ubuntu o una distribución Debian usan los comandos
sudo apt-get install flex
sudo apt-get install bison
O si lo prefieren pueden usar el modo grafico usando Synaptic.
En la siguiente entrada veremos un ejemplo de flex y bison, el mismo de la calculadora que hicimos con JLlex y Cup.
sábado, 26 de marzo de 2011
Ejemplo JLex y Cup
Siguiendo con nuestro pequeño ejemplo de un compilador, ahora agregaremos una gramática para realizar el análisis sintáctico de nuestro ejemplo de la calculadora. Recordemos que este ejemplo esta realizado en Windows y ya tienes que tener las herramientas instaladas, si no las tienes, lee antes: Instalar JLex y Cup en W7 y Uso de JLex sin usar Cup.
Modificaremos nuestro archivo lexico.jlex ya que ahora lo integraremos con cup, el nuevo archivo nos quedaría de la siguiente forma:
import java_cup.runtime.Symbol;
%%
%eofval{
{ System.exit(0); }
%eofval}
%cup
%line
%char
%state COMENTARIO
NUMBER = [1-9][0-9]*
%%
/*
* Uno de los cambios más importantes es que ahora usamos return, que esto lo que hace es
* retornar y enviar el token a nuestro analizador léxico. En este caso retornaremos un
* no terminal por medio de la función Symbol
*/
/* En la siguiente línea, además de pasar el no terminal NUMERO a cup, pasamos un valor
entero, que es el valor numérico de nuestra entrada */
<YYINITIAL> {NUMBER} { return new Symbol(sym.NUMERO, new Integer(yytext())); }
<YYINITIAL> "+" { return new Symbol(sym.MAS); }
<YYINITIAL> "-" { return new Symbol(sym.MENOS); }
<YYINITIAL> "*" { return new Symbol(sym.POR); }
<YYINITIAL> "/" { return new Symbol(sym.DIV); }
<YYINITIAL> "(" { return new Symbol(sym.PARI); }
<YYINITIAL> ")" { return new Symbol(sym.PARD); }
<YYINITIAL> ";" { return new Symbol(sym.FIN); }
<YYINITIAL> " " {}
<YYINITIAL> [\t\r\n\f] {}
<YYINITIAL> "//" {yybegin(COMENTARIO);}
<COMENTARIO> [^\n] {}
<COMENTARIO> [\n] {yybegin(YYINITIAL); yychar=0;}
<COMENTARIO> .|\n {if(!(yytext().equals("\n")))
System.out.println("error lexico en " + yyline + "," + yychar + " No se reconoce " + yytext());
yychar=0; }
Luego de modificar nuestro archivo léxico.jlex, definimos la gramática que utilizaremos en para el análisis sintáctico. La gramática es la siguiente
E -> E + T
| T
T -> T - F
| F
F -> F * G
| G
G -> G / H
| H
H -> (E)
| n
La gramática anterior nos produce los terminales y no terminales para aceptar expresiones que contengan operaciones aritméticas (+,-,* y /). Ahora definimos nuestro archivo sintactico.cup, el cual contendrá lo siguiente:
/* Importamos las clases necesarias del paquete cup.jar */
import java_cup.runtime.*;
/**
* Aquí ponemos el código que se usará para comenzar a parsear la entrada.
*/
parser code {:
public static void main(String args[]) throws Exception {
// La clase Yylex es creada por el analizador léxico
new parser(new Yylex(System.in)).parse();
}
:}
/* Aquí especificamos los terminales del lenguaje. */
terminal MAS, MENOS, POR, DIV, PARI, PARD, FIN;
/**
* Este terminal tiene un valor entero. Recuerda que le dábamos el valor
* en el código del analizador léxico, al darle como parámetro un valor
* entero al objeto Symbol.
*/
terminal Integer NUMERO;
/* Lista de no terminales. */
non terminal expr_list, expr_part;
/**
* Aquí están los no terminales con valor entero, que son con los que
* podemos hacer cálculos, y podemos escribirlos de la forma expr_e:l
* (por ejemplo, no se podría hacer expr_list:l, ya que a ese no
* terminal no le damos valor.
*/
non terminal Integer expr_e;
non terminal Integer expr_t;
non terminal Integer expr_f;
non terminal Integer expr_g;
non terminal Integer expr_h;
/* Aquí especificamos la precedencia de los operadores. */
precedence left MAS;
precedence left MENOS;
precedence left POR;
precedence left DIV;
/**
* Ahora comenzamos con las reglas de producción.
*/
/**
* Estas dos reglas son nuevas. Nos sirven para encadenar varias
* expresiones separadas por un ';'
*/
expr_list ::= expr_list expr_part | expr_part
;
/*
*Al hacer "expr_e:e", podemos usar esta "e" para realizar cualquier operacion
* ya que cup guarda el valor que trae expr_e en la variable e, en este caso un numero.
*/
expr_part ::= expr_e:e {: System.out.println("= "+e); :} FIN
;
/*
* Como nos damos cuenta en las siguientes lineas, podemos realizar las operaciones
* con los valores obtenidos en la gramatica, con las variables l y r y estas las
* retorna, guardando en el no terminal expr_e
*/
expr_e ::= expr_e:l MAS expr_t:r {: RESULT=new Integer(l.intValue() + r.intValue()); :}
| expr_t:e {: RESULT=e; :}
;
expr_t ::= expr_t:l MENOS expr_f:r {: RESULT=new Integer(l.intValue() - r.intValue()); :}
| expr_f:e {: RESULT=e; :}
;
expr_f ::= expr_f:l POR expr_g:r {: RESULT=new Integer(l.intValue() * r.intValue()); :}
| expr_g:e {: RESULT=e; :}
;
expr_g ::= expr_g:l DIV expr_h:r {: RESULT=new Integer(l.intValue() / r.intValue()); :}
| expr_h:e {: RESULT=e; :}
;
expr_h ::= PARI expr_e:e PARD {: RESULT=e; :}
| NUMERO:n {: RESULT=n; :}
;
Ya definido nuestros archivos léxico.jlex y sintáctico.cup, compilamos con los siguientes comandos::
· Compilamos el lexico.jlex
java JLex.Main lexico.jlex
· Renombramos el archive generado, lexico.jlex.java ya Yylex.java
· Compilamos el sintáctico.cup
java java_cup.Main sintactico.cup
· Compilamos los arhivos generados, parser.java, sym.java y Yylex.java con el siguiente comando.
· ]javac -d . parser.java sym.java Yylex.java
Listo, para ejecutar, necesitamos un archivo por ejemplo entrada.txt con algunas operaciones aritméticas, por ejemplo
1 + 2 * 3/2;
1+3*(4-2)/2;
3+4;
Ejecutamos con el comando:
java parser 0<entrada.txt
Listo, espero les sirva este pequeño ejemplo, pueden descargar el ejemplo completo en Ejemplo JLex y Cup
martes, 22 de marzo de 2011
Tarjeta Inalámbrica bloqueada en Linux
Mi problema con mi tarjeta, es que cuando inicia Linux está bloqueada por hardware y software, no soy un experto en Linux, se algunas cosas, pero me falta mucho, por eso tarde varios días en dar con este problema y por esa razón lo publico pues a alguien le pude servir.
Deben de asegurarse de que los controladores estén bien instalados, mi problema no era de controladores, ya que Linux me reconoce la tarjeta.
Este problema me sucedía con ubuntu 10.10, y ahora que instale Opensuse 11.3 también pasa lo mismo, encontré una solución aunque creo que no es la óptima, porque si apagas la tarjeta inalámbrica, al reiniciar tienes que desbloquearla desde consola, pero me ha funcionado.
Primero para poder usar los comandos necesitamos un programa que nos servirá para desbloquear la tarjeta inalámbrica, para instalar usamos
~> OpenSuse
~> sudo zypper in rfkill
Ubuntu
~> sudo apt-get install rfkill
Puedes también usar synaptic o yast, dependiendo tu distro, a mi me gusta usar la consola, es mucho más rápido.
Ya que instalamos puedes ver si función, escribe el siguiente comando
~> Sudo rfkill list wifi
Eso me da una salida como la siguiente
0: hp-wifi: Wireless LAN
Soft blocked: yes
Hard blocked: yes
1: phy0: Wireless LAN
Soft blocked: yes
Hard blocked: yes
Si se dan cuenta, la tarjeta está bloqueada tanto por hardware como por software, para poder desbloquear usamos el siguiente comando
~> sudo rfkill unblock 0
~> sudo rfkill unblock 1
o si lo prefieren pueden hacerlo todo con un solo comando
~> sudo rfkill unblock all
Ya con esto, vemos nuevamente el estado de la tarjeta con el comando rfkill list wifi y lo que nos muestra ahora es
0: hp-wifi: Wireless LAN
Soft blocked: no
Hard blocked: no
1: phy0: Wireless LAN
Soft blocked: no
Hard blocked: no
Listo, ya podemos conectarnos a internet con la tarjeta inalámbrica
sábado, 12 de marzo de 2011
Instalar controlador LEGO MINDSTORMS NXT en Windows 7
He tratado de instalar los controladores del Ladrillo (Brick) de Lego en Windows 7 de 64 bits, pero no me ha salido a la primera, por lo que publico esta pequeña guía para aquellos que tengan el mismo problema.
Lo primero que necesitamos es descargar el controlador para W7, el archivo se llama NXT_64bit_driver.zip” y lo pueden encontrar en el siguiente link:
Ahora, si como yo, has tratado de instalar antes el controlador, primero desinstala todo lo relacionado con Lego.
Descomprime el archivo que descargaste anteriormente, y dentro existe un archivo con el nombre de “LegoMindstormsNXTdriver64.msi”, ejecútalo, sigue los pasos y deja los parámetros predeterminados que trae. No tienes que tener conectado el ladrillo a la computadora.
Ahora sí, conecta el ladrillo a la computadora y enciéndelo. Veras que Windows iniciara con la instalación de los controladores para poder trabajar con el ladrillo. Para comprobar que todo ha salido bien, nos vamos a administrador de dispositivos y si buscamos, encontramos el lego.
Suscribirse a:
Entradas (Atom)