Problema de instalación: No se ha instalado correctamente la configuración ...

"Problema de instalación, no se ha instalado correctamente la configuración predeterminada para el gestor de energía. Contacte con el administrador de su sistema".

Este mensaje se me presento ayer por la noche al iniciar sesión en mi sistema Ubuntu, en la ventana de loggin escribía mis datos y me regresaba de nuevo a esta ventana, creí que había un problema con la batería pues últimamente me he percatado de que ya no rinde como los primeros días de uso.

Por suerte al estar investigando encontré la solución, y quiero aclarar que este problema no esta relacionado con la batería del equipo, sino, con la partición raíz ( / ) de nuestro sistema, en mi caso le deje 15 Gb y de tantos programas que he instalado termine por llenar ese espacio, por ese motivo me mostraba el mensaje que he colocado al principio de la página.

Lo que hice para solucionar el problema y poder entrar de manera normal a Ubuntu, fue lo siguiente:

• Encender el equipo y elegir la opción ... (mode recovery)

• Iniciar en modo de recuperación (desde linea de comandos)
• escribir df -h (comando para visualizar las particiones, aquí note, que efectivamente mi partición raíz estaba completamente llena)
• escribir dpkg --get-selections | grep linux-image (este comando despliega una lista con las actualizaciones del kernel)
• Posteriormente pase a borrar las imágenes del kernel que ya no eran necesarias, ojo, no borrar la imágen más actual ni la anterior a esa, esta última por precaución.
• El comando para borrar las imágenes es:
  apt-get --purge remove linux-image-2.6.32.xx-generic (esto último en base a la lista que hayan obtenido con el comando escrito anteriormente)
• Observamos de nuevo el tamaño de las particiones y podemos notar que la partición raíz ya tiene más espacio.
• Reiniciamos y entramos a nuestro sistema.

Pero el problema no termina aquí, para que no les vuelva a pasar este problema deben redimensionar la partición raíz para que tenga más espacio ya sea con gparted u otro programa que facilite esta tarea.


 Espero les sirva de ayuda.
Hasta la proxima!!!

Programar un Microcontrolador en Linux (Ubuntu)

Pues de nuevo me encuentro escribiendo un pequeño manual esperando ayudar a estudiantes que se hayan visto en el mismo problema que yo, que es el  programar un microcontrolador usando lenguaje C en una distribución de linux, en mi caso Ubuntu.

Para esto solo usaremos dos herramientas que ya están incluidas en nuestro sistema, las cuales son:

• Un editor de texto plano (gedit, kate, etc.)
• Terminal

Antes de empezar a programar debemos tener las herramientas necesarias para poder compilar y crear nuestros archivo .hex que es el que usaremos para programar el microcontrolador.

Instalamos lo siguiente:

sudo apt-get install avr-libc binutils-avr avrdude gcc gcc-avr

Ahora si, ya podemos empezar a programar. 

Para ver la manera de compilar nuestro programa y generar el archivo .hex desde la terminal, haremos un programa sencillo que enciende y apaga un led.

Abrimos nuestro editor de texto y copiamos el siguiente codigo:

#include <avr/io.h>

#include <avr/iom8535.h> //biblioteca para el atmega8535

#define F_CPU 1000000UL

#include <util/delay.h>

int main(void)

{

DDRB = 0x01; //pone portb para salida

while(1){

PORTB = 0b00000001; //prende el led inicialmente

_delay_ms(250); //esperamos 250 mili-segundos

PORTB = 0b00000000; //apaga el led

_delay_ms(250); //esperamos 250 mili-segundos

}

return 1;

}

Por el momento no explicaré el código, ya que el motivo de este tutorial es para compilar y crear el archivo .hex usando una distribución de Linux.

Para compilar nuestro programa nos dirigimos a la ubicación donde hemos guardado nuestro archivo, una vez estando ahí abrimos una terminal y escribimos lo siguiente:

avr-gcc -mmcu=atmega8535 nombre_programa.c -o nombre_salida

Notemos que -mmcu=atmega8535 es el microcontrolador en el cual cargaré el .hex, dependiendo del microcontrolador que vayan a usar será el nombre que deberán incluir.

-mmcu=nombre_del_uc_a_usar

Si nuestro programa no generó errores es hora de pasar a la creación de nuestro .hex, para esto en la terminal escribimos lo siguiente.

avr-objcopy -O ihex nombre_salida source.hex 

Y con esto hemos generado nuestro archivo .hex que será el que programaremos en el microcontrolador.

Para ver su funcionamiento podemos hacer uso de Proteus , esto lo explicaré posteriormente en mi canal de youtube.

Espero que este pequeño tutorial haya sido de ayuda. 

Hasta la próxima... 

Servidor-UDP en C

Ahora es turno de mostrar el código fuente de nuestro servidor no orientado a conexión.
El código es sencillo de entender por lo que no considero necesario explicarlo.

/*************************************************************
* Prueba de un Servidor NO orientada a conexion (UDP)
*************************************************************/
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
//variables globales para el servidor
#define MAXBUFFER 100

struct sockaddr_in my_direcc; //contendra la direccion ip y el puerto del servidor
struct sockaddr_in client; //contendra la direccion ip y el puerto del cliente
int sockfd,addr_len;
int MYPORT;
char buffer[MAXBUFFER];
char sendBuffer[MAXBUFFER];
//creamos el socket
void crearSocket()
{
if((sockfd = socket(AF_INET,SOCK_DGRAM,0))==-1){
perror("Socket");
exit(1);
}
}

void atributos()
{
my_direcc.sin_family = AF_INET;
my_direcc.sin_port = htons(MYPORT);
my_direcc.sin_addr.s_addr = INADDR_ANY; //se usa la ip local, permite conexiones de cualquier direccion
bzero(&(my_direcc.sin_zero),8);
}

void socket_name()
{
if(bind(sockfd,(struct sockaddr*)&my_direcc,sizeof(struct sockaddr))==-1){
perror("bind");
exit(1);
}
}

void recibir()
{
addr_len = sizeof(struct sockaddr);
if(recvfrom(sockfd,buffer,MAXBUFFER,0,(struct sockaddr*)&client,(socklen_t*)&addr_len)==-1){
perror("Recibir");
exit(1);
}
else{
printf("%s \n",buffer);
printf("direction IP: %s \t",inet_ntoa(client.sin_addr));
printf("PORT: %d \n",MYPORT);
}
}

void enviarDato()
{
sprintf(sendBuffer,"confirmation of message received");
if(sendto(sockfd,sendBuffer,MAXBUFFER,0,(struct sockaddr*)&client,sizeof(struct sockaddr))<0){
perror("function sendto");
exit(1);
}
}

void cerrarSocket()
{
close(sockfd);
}

int main(int argc, char *argv[])
{
if(argc > 1)
{
MYPORT = atoi(argv[1]);
crearSocket();
atributos();
socket_name();
recibir();
enviarDato();
cerrarSocket();
}
else
printf("Error: invalid arguments\n");
return 1;
} 

Como podrán observar nuestro servidor requiere de 2 argumentos que le debemos indicar desde linea de comandos, los cuales son:

• Nombre del programa.
• Puerto, que es por donde se transmitirá la información.

Y así doy por finalizado este sencillo tutorial donde se llevo acabo la creación de un cliente-servidor no orientado a conexión bajo una distribución de Linux, en este caso Ubuntu 10.04, espero que les haya servido de algo.

Hasta la próxima . . . 

Cliente-UDP en C

Lo prometido es deuda, el código fuente que a continuación se muestra es para crear nuestro cliente NO orientado a conexión.

No explicaré el código, pues las funciones usadas en este programa fueron explicadas  en este apartado.

Código fuente:

/*****************************************************************

* Prueba de un Cliente NO orientada a conexion (UDP)

*****************************************************************/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <errno.h>

#include <string.h>

#include <netdb.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <sys/socket.h>

//longitud máxima del buffer

#define MAX_BUFFER 1000

//atributos para el uso del socket

char sendBuffer[MAX_BUFFER];

char recvBuffer[MAX_BUFFER];

int direccIP;

int PORT;

int sockfd;

int sock_len;

struct sockaddr_in serv_addr; //informacion de la direccion de destino

size_t len;

void crearSocket()

{

if((sockfd = socket(AF_INET,SOCK_DGRAM,0))==-1){

perror("Socket");

exit(1);

}

}

void atributos()

{

//atributos del servidor

  len = sizeof(struct sockaddr_in);

  serv_addr.sin_family = AF_INET;    // Ordenación de bytes de la máquina 

  serv_addr.sin_port = htons(PORT);  // short, Ordenación de bytes de la red 

  serv_addr.sin_addr.s_addr = direccIP;

}

void enviarDato()

{ //enviamos el mensaje 'hello world'

sprintf(sendBuffer,"hello world");

if(sendto(sockfd,sendBuffer,strlen(sendBuffer),0,(struct sockaddr*)&serv_addr,len)<0){

perror("function sendto");

exit(1);

}

}

void recibirDato()

{ //recibimos la respuesta del servidor

sock_len = sizeof(struct sockaddr);

if(recvfrom(sockfd,recvBuffer,MAX_BUFFER,0,(struct sockaddr*)&serv_addr,(socklen_t*)&sock_len)<0){

perror("function recvfrom");

exit(1);

}

else

printf("%s \n",recvBuffer);

}

void cerrarSocket()

{

close(sockfd);

}

int main(int argc,char *argv[])

{

if(argc > 1){

direccIP = inet_addr(argv[1]);

PORT = atoi(argv[2]);

crearSocket();

atributos();

enviarDato();

recibirDato();

cerrarSocket();

}

else

{

printf("Error: intent ./name_program direction_IP port\n");

}

} 

Como podrán observar el programa recibe 3 parámetros desde linea de comandos  que son:

• Nombre del programa.
• Dirección IP de la PC con la deseamos hacer la comunicación.
• Puerto por el cual se transmitirá la información.

Lenguaje Java

En esta sección podrán consultar información sobre algunos aspectos de programación usando lenguaje JAVA.

Creación de un applet animado.

Lenguaje C

En esta sección podrán consultar información sobre algunos aspectos de programación usando lenguaje C.

1. Cliente-Servidor UDP en Linux.
2. Cliente-UDP en C.
3. Servidor-UDP en C.
4. Juego de la vida.

/*****************************************/

1. Programación de Microcontroladores en Linux (Ubuntu).

Creación de un applet animado

En esta ocasión crearemos un applet sencillo, donde se muestra la animación de una pelota que se desplaza en el eje X.
Antes de mostrar el código daremos un pequeño resumen de las funciones que se utilizaron para esta animación.

¿Que es un applet?
Un applet desde el punto de vista de código java lo podemos definir como un pequeño programa diseñado para ser ejecutado en el contexto de una página web y desde el punto de vista de una página html representa una pequeña ventana gráfica dentro de la misma.

Un applet se carga y se ejecuta desde cualquier explorador que soporte java.

Creación de un applet
Para crear un applet, únicamente necesitamos escribir una clase que derive de la clase Applet que se encuentra en el paquete java.applet

Los métodos para crear nuestra animación son los siguientes:

public void init():  este método es llamado una sola vez cuando se carga el applet, es usado generalmente para cargar los componentes del applet, por ejemplo: cargar las imágenes y sonidos, crear los botones, etiquetas, etc.

public void start(): este método sera llamado cada vez que se inicie la ejecución del applet. Esto es después de que se ejecute el método init() y cada vez que se vuelva a mostrar la página web que muestra el applet.

public void stop(): Este método es llamado para informar al applet que su ejecución va a ser detenida. Esto ocurre siempre que la página que muestra el applet es remplazado por otra página y justo antes de que sea destruido.

public void paint(): La clase Applet hereda este método de la clase Container. Es llamado cada vez que es necesario repintar el contenedor del applet, es decir;  el área de dibujo. El parámetro g  de la clase Graphics que pertenece al paquete java.awt, hace referencia a la ventana gráfica.

Creación de la animación
Para hacer la animación de nuestro applet haremos uso de un hilo (Thread  - llamado también proceso ligero o subproceso ) no explicaremos lo que es un hilo, ya que no es nuestra intención alargar mas el tema. Los hilos en java se pueden crear de dos formas:

•  Escribiendo una nueva clase derivada de Thread que se encuentra en el paquete java.awt.
• Hacer que una clase existente implemente la interfaz Runnable.

Una clase que implemente la interfaz Runnable tiene que sobreescribir el método run  aportado por ésta. El método run deberá tener el código que debe ejecutar el hilo.


El código es el siguiente:

import java.awt.*;
import java.applet.*;

public class MiApplet extends Applet implements Runnable {
    Thread anima;  //creación del hilo 
    int radio=10;     //radio de la pelota
    int x, y;       //posición del centro de la pelota
    int dx = 1;     //desplazamiento en x
    int retardo = 50; 
    int anchoApplet;
    int altoApplet;

  public void init(){
    setBackground(Color.white);
//dimensiones del applet
    anchoApplet = getSize().width;
    altoApplet = getSize().height;
//posición inicial de partida
    x = anchoApplet/4;
    y = altoApplet/2;
  }

  public void start(){
     if(anima  == null){
        anima= new Thread(this);
        anima.start();
     }
  }

  public void stop(){
     if(anima != null){
        anima = null;
     }
  }

  public void run(){
    while (true) {
        mover();
        try{
        Thread.sleep(retardo);
        }catch(InterruptedException e){
        break;
        }
    }
  }
  void mover(){
    x += dx;
    if (x >= (anchoApplet-radio) || x < radio) dx*= -1;
    repaint();   //llama a paint
  }

  public void paint(Graphics g){
    g.setColor(Color.red);
    g.fillOval(x-radio, y-radio, 2*radio, 2*radio);
  }
}