Soluciones Informática Electrónica Práctica 3

Acá van mis soluciones para los ejercicios de informática electrónica práctica 3.

Todas las soluciones fueron implementadas usando 4.4.3

AVISO: No me siento exactamente muy alegre con todas las soluciones 😉

Ejercicio 2:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct Indice Indice;

char ** oraciones;
long int cant_oraciones;
long int tam_oraciones;

char acumulador[256];

void agregarPalabra(char *palabra){
    if ( cant_oraciones == tam_oraciones ){
        // agrandar Buffer
        if (tam_oraciones)
            tam_oraciones = tam_oraciones << 2; // multiplicar por 2 tamaño
        else
            tam_oraciones = 1;
        oraciones = realloc(oraciones, sizeof(char **) * tam_oraciones);
    };
    oraciones[cant_oraciones]=strdup(palabra);
    cant_oraciones++;
}

int main(void){
        char buffer[1000]; // buffer de lectura
        char ** puntero;
        int len = 0;
        int i = 0;
        char car;
        printf("Ingrese texto, presione enter para terminar\n");
        printf("Una linéa vacia o EOF se considera fin\n");

        while (1){
                printf("> ");
                gets(buffer);//buffer, sizeof(buffer), stdin); // leer entrada
                len = strlen(buffer);

                if (len==0 || buffer[0]=='\n'){
                        printf("FIN\n");
                        break;
                }

                for (i=0; i<len; i++){
                        car = buffer[i] & 0xff; // limitar a ASCII de 8 bits
                        acumulador[(int)(car&0x00ff)]+=1;
                }


                agregarPalabra(buffer);
        }

        i = 0;
        puntero=oraciones;
        if (!puntero)
                return 0;

        while (i < cant_oraciones){
                printf("%i: %s\n", i+1, *puntero);
                i++;
                puntero++;
        }

        for (i=0; i<255; i++){
                car = (char) i & 0xff;
                if (acumulador[i]==0)
                        continue;

                printf("%c\t%0X:\t%i\n", car, 0xff&car, acumulador[i]);
        }
        return 0;
}

Ejercicio 3:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

char ** frases=0;
int * ocurrencias=0;
int cant_frases=0;
int espacio_reservado=0;

void agregar(const char * frase){
        int i;

        // primero verificar si la conocemos
        for ( i = 0; i < cant_frases; i++){
                if (strcmp(frase, frases[i]) == 0)
                {
                        ocurrencias[i]+=1;
                        return;
                }
        }

        // ok no la conocemos a agregarla a la lista.

        if ( i == espacio_reservado){
                // crecimiento exponencial del consumo de memoria
                if (espacio_reservado)
                        espacio_reservado=espacio_reservado<<1;
                else
                        espacio_reservado=2;
                printf("realloc para %i elementos\n", espacio_reservado);
                frases = realloc(frases, sizeof(char*)*espacio_reservado);
                ocurrencias = realloc(ocurrencias, sizeof(int)*espacio_reservado);
        }

        frases[i] = strdup(frase);
        ocurrencias[i] = 1;
        cant_frases+=1;
}

int leerPalabra(char * buffer){
        char c;
        while ( 1 ){
                c = getchar();
                if ( isspace(c) || ispunct(c) || c==0 ){
                        *buffer=0;
                        return 0;
                }
                if (c==EOF){
                        *buffer=0;
                        return 1;
                }

                *buffer = c;
                buffer++;
        }
}

void ordenar(){
        int i, j;
        char * tempc;
        int tempi;
        int test; /* permite saber si esta terminado */
        for(i = cant_frases - 1; i > 0; i--)
        {
                test=0;
                for(j = 0; j < i; j++)
                {
                        if(strcmp(frases[j], frases[j+1]) > 0)
                        /* comparar elementos vecinos */
                        {
                                tempc = frases[j]; /* intercambiar elementos*/
                                frases[j] = frases[j+1];
                                frases[j+1] = tempc;

                                tempi = ocurrencias[j]; /* intercambiar elementos*/
                                ocurrencias[j] = ocurrencias[j+1];
                                ocurrencias[j+1] = tempi;

                                test=1;
                        }
                } /*end for j*/
                if(test==0) break; /*will exit if the list is sorted!*/
        } /*end for i*/

}

int main(void){
        char buffer[1000]; // buffer de lectura
        char c;
        int len, i;
        printf("Ingrese palabras, EOF para terminar\n");

        while (1){
                i = leerPalabra(&buffer);
                len = strlen(buffer);

                printf ("%s\n", buffer);
                if (len > 0){
                        agregar(buffer);
                        continue;
                }

                if (i==1){
                        printf("FIN\n");
                        break;
                }
        }

        printf("SIN ORDENAR\n");
        for (i=0; i<cant_frases; i++){
                printf("%s: %i\n", frases[i], ocurrencias[i]);
        }

        printf("\n\n");
        printf("ORDENADO\n");
        ordenar();
        for (i=0; i<cant_frases; i++){
                printf("%s: %i\n", frases[i], ocurrencias[i]);
        }


        return 0;
}

Ejercicio 4:
Similar al 3 pero con estructuras!


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct Frase Frase;

struct Frase{
	char * frase;
	int  ocurrencias;
};

Frase * frases=0;
int cant_frases=0;
int espacio_reservado=0;

void agregar(const char * frase){
	int i;

	// primero verificar si la conocemos
	for ( i = 0; i < cant_frases; i++){
		if (strcmp(frase, frases[i].frase) == 0)
		{
			frases[i].ocurrencias+=1;
			return;
		}
	}

	// ok no la conocemos a agregarla a la lista.

	if ( i == espacio_reservado){
		// crecimiento exponencial del consumo de memoria
		if (espacio_reservado)
			espacio_reservado=espacio_reservado<<1;
		else
			espacio_reservado=2;
		printf("realloc para %i elementos\n", espacio_reservado);
		frases = realloc(frases, sizeof(Frase)*espacio_reservado);
	}

	frases[i].frase = strdup(frase);
	frases[i].ocurrencias = 1;
	cant_frases+=1;
}

int leerPalabra(char * buffer){
	char c;
	while ( 1 ){
		c = getchar();
		if ( isspace(c) || ispunct(c) || c==0 ){
			*buffer=0;
			return 0;
		}
		if (c==EOF){
			*buffer=0;
			return 1;
		}

		*buffer = c;
		buffer++;
	}
}

void ordenar(){
	int i, j;
	Frase temp;
	int test; /* permite saber si esta terminado */
	for(i = cant_frases - 1; i > 0; i--)
	{
		test=0;
		for(j = 0; j < i; j++)
		{
			if(strcmp(frases[j].frase, frases[j+1].frase) > 0)
			/* comparar elementos vecinos */
			{
				temp = frases[j]; /* intercambiar elementos*/
				frases[j] = frases[j+1];
				frases[j+1] = temp;
				test=1;
			}
		} /*end for j*/
		if(test==0) break; /*will exit if the list is sorted!*/
	} /*end for i*/

}

int main(void){
	char buffer[1000]; // buffer de lectura
	int len, i;
	printf("Ingrese palabras, EOF para terminar\n");

	while (1){
		i = leerPalabra(&buffer);
		len = strlen(buffer);

		printf ("%s\n", buffer);
		if (len > 0){
			agregar(buffer);
			continue;
		}

		if (i==1){
			printf("FIN\n");
			break;
		}
	}

	printf("SIN ORDENAR\n");
	for (i=0; i<cant_frases; i++){
		printf("%s: %i\n", frases[i].frase, frases[i].ocurrencias);
	}

	printf("\n\n");
	printf("ORDENADO\n");
	ordenar();
	for (i=0; i<cant_frases; i++){
		printf("%s: %i\n", frases[i].frase, frases[i].ocurrencias);
	}

	return 0;
}

Ejercicio 5:
Usando lista enlazada, ordenando al momento de cargar, cómo me gusta las estructuras es lo más semejante que conozco a las estructuras de python :D.
Si me preguntan la forma más eficiente de hacerlo, sobre todo con MUCHOS datos!

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct Frase Frase;

struct Frase{
	char * frase;
	int  ocurrencias;
	Frase * proxima;
};

Frase * inicio=0;

void agregar(const char * frase){
	int i;
	Frase * puntero = inicio;
	Frase * previo = 0; //estupido C no inicializa en 0, sin esto tira verdura!
	Frase * nueva;
	printf("agregando %s\n", frase);

	// primero verificar si la conocemos
	while ( puntero ){
		i = strcmp(frase, puntero->frase);
		if ( i == 0 )
			// la encontramos
		{
			printf("conocida sumando\n");
			puntero->ocurrencias+=1;
			return;
		} else
		if (i < 0){
			// estamos metiendo una nueva frase que es mayor a la última
			// que estabamos mostrando, entonces podemos insertar de forma
			// ordenada
			nueva = malloc(sizeof(Frase));
			nueva->frase = strdup(frase);
			nueva->ocurrencias = 1;
			nueva->proxima = puntero;
			if (previo){
				previo->proxima = nueva;
				printf("agreagando entre %s y %s\n", previo->frase, puntero->frase);
			}
			else {
				inicio = nueva;
				printf("a la cabeza\n");
			}

			return;
		}

		previo = puntero;
		if (puntero->proxima==NULL)
			break;
		puntero = puntero->proxima;
	}

	// puntero apunta a la última frase
	// no la conocemos a agregarla a la lista al final.
	printf("agregando al final\n");
	nueva = malloc(sizeof(Frase));
	nueva->frase = strdup(frase);
	nueva->ocurrencias = 1;
	nueva->proxima = 0;
	if (puntero){
		printf("agregando luego de %s\n", puntero->frase);
		puntero->proxima = nueva;
	}
	if (!inicio){
		printf("inicio de la lista\n");
		inicio = nueva;
	}
}

int leerPalabra(char * buffer){
	char c;
	while ( 1 ){
		c = getchar();
		if ( isspace(c) || ispunct(c) || c==0 ){
			*buffer=0;
			return 0;
		}
		if (c==EOF){
			*buffer=0;
			return 1;
		}

		*buffer = c;
		buffer++;
	}
}

int main(void){
	char buffer[1000]; // buffer de lectura
	int len, i;
	Frase * puntero;
	printf("Ingrese palabras, EOF para terminar\n");

	while (1){
		i = leerPalabra(&buffer);
		len = strlen(buffer);

		printf ("%s\n", buffer);
		if (len > 0){
			agregar(buffer);
			continue;
		}

		if (i==1){
			printf("FIN\n");
			break;
		}
	}

	printf("ORDENADA\n");
	puntero = inicio;
	while (puntero){
		printf("%s: %i\n", puntero->frase, puntero->ocurrencias);
		puntero = puntero->proxima;
	}
	return 0;
}

Ejercicio 6:
Si me preguntan no sé quién escribió un código tan feo, es cómo rascarse la oreja izquierda con la mano derecha, igualmente lo corregí para compilar en GCC.

#include <stdlib.h>
#include <stdio.h>
void main () {
        int *vector, *matriz, *resultado;
        int i,j, nCol, *pi, *pm, *pr;

        srand48 (time(NULL));

        printf("Introduce el numero de columnas del vector/matriz: ");
        scanf("%d",&nCol);

        
        /* Asignamos memoria para vectores y matrices */
        vector          = malloc(sizeof(int)*nCol);
        matriz          = malloc(sizeof(int)*nCol*nCol);
        resultado       = malloc(sizeof(int)*nCol);
        if(vector == NULL || matriz == NULL || resultado == NULL){
                printf("\nError en la memoria");
                return;
        }
        printf("\nLa memoria asignada es: ");
        printf("$\n%10s%10s%10s%10s", "Area","Inicio","Largo","Ultima");
        printf("\n%10s%10x%10d%10x", "Vector", vector,  sizeof(int)*nCol,       vector+nCol);
        pm=matriz+nCol*nCol;
        printf("\n%10s%10x%10d%10x", "Matriz", matriz,  sizeof(int)*nCol*nCol,  pm);
        pi=resultado;
        pm=resultado+nCol;
        printf("\n%10s%10x%10d%10x", "Resultado", pi,   pm - resultado, pm);

        /* "Introduce valores para el vector: "; */
        printf("\n\nEl vector es:\n");
        /*for (i=0, pi=vector; i<nCol; i++, pi++){*/
        for (pi=vector, pm=(vector+nCol); pi<pm; pi++){
                *pi =   (int) (drand48() * 10);
                printf("%10d", *pi);
        }
        /* "Introduce valores para la fila " */
        printf("\n\nLa matriz es:\n");
        for (i=0,pi=matriz, pm=(matriz+nCol*nCol); pi<pm; pi++, i++){
                *pi =   (int) (drand48() * 10);;
                printf("%10d", *pi);
                if((i+1)%nCol==0)
                        printf("\n");
        }
        /* Multiplicando */
        printf("\n\nOperaciones realizadas:\n");
        pi=vector;
        pm=matriz;
        pr=resultado;
        for (i=0; i<nCol; i++, pi++, pr++) {
                *pr = 0;
                for ( j=0; j<nCol; j++, pm++) {
                        *pr += *pi * *pm;
                        printf("%5d*%-4d", *pi,*pm);
                }
                printf("= %d\n", *pr);
        }
        printf("\nEl resultado es: \n");
        for (i=0,pi=resultado; i<nCol; i++, pi++)
                printf("%10d", *pi);
        printf("\n");

}

Ejercicio 7
Haciendo el acceso a matrices un poco más coherentes.

#include <stdlib.h>
#include <stdio.h>
int main (void) {
        int *matriz1, *matriz2, *resultado;
        int i,j, k, nCol1, nFil1, nCol2, nFil2, *pi, *pm, *pr;

        srand48 (time(NULL));

        printf("Introduce el numero de columnas y filas de la matriz 1 (separadas con espacios): ");
        scanf("%d %d",&nCol1, &nFil1);

        printf("Introduce el numero de columnas y filas de la matriz 2 (separadas con espacios): ");
        scanf("%d %d",&nCol2, &nFil2);

        if (nCol1 != nFil2){
            printf("Tamaños de matrices incompatibles\n");
            return 1;
        }

        matriz1         = malloc(sizeof(int)*nCol1*nFil1);
        matriz2         = malloc(sizeof(int)*nCol2*nFil2);
        resultado       = malloc(sizeof(int)*nCol2*nFil1);
        if(matriz1 == NULL || matriz2 == NULL || resultado == NULL){
                printf("\nError en la memoria");
                return 1;
        }
        printf("\nLa memoria asignada es: ");
        printf("$\n%10s%10s%10s%10s", "Area","Inicio","Largo","Ultima");
        printf("\n%10s%10x%10d%10x", "Matriz1", matriz1, sizeof(int)*nCol1*nFil1, matriz2-1);
        printf("\n%10s%10x%10d%10x", "Matriz2", matriz2, sizeof(int)*nCol2*nFil2, resultado-1);
        printf("\n%10s%10x%10d%10x", "Resultado", resultado, sizeof(int)*nFil1*nCol2, resultado+(nCol1*nFil2));

        printf("\n\nLa matriz 1 es:\n");
        pi=matriz1;
        for (i=0; i<nFil1; i++){
            for (j=0; j<nCol1; j++){
                *(pi+i*nCol1+j) = (int) (drand48() * 10);
                printf("%10d", *(pi+i*nCol1+j));
            };
            printf("\n");
        };

        printf("\n\nLa matriz 2 es:\n");
        pi=matriz2;
        for (i=0; i<nFil2; i++){
            for (j=0; j<nCol2; j++){
                *(pi+i*nCol2+j) = (int) (drand48() * 10);
                printf("%10d", *(pi+i*nCol2+j));
            };
            printf("\n");
        };

        printf("\n\nOperaciones realizadas:\n");
        pi=matriz1;
        pm=matriz2;
        pr=resultado;

        for(i=0; i<nFil1; i++){
           for(j=0; j<nCol2; j++){
              for(k=0; k<nCol1; k++){
                *(pr+i*nCol2+j)+=*(pi+i*nCol1+k) * *(pm+k*nCol2+j);
                printf("%5d*%-4d", *(pi+i*nCol1+k), *(pm+k*nCol2+j));
              }
              printf("= %d\n", *(pr+i*nCol2+j));
           }
        }

        pi = resultado;
        printf("\nEl resultado es: \n");
        for (i=0; i<nCol2; i++){
            for (j=0; j<nFil1; j++){
                printf("%10d", *(pi+i*nFil1+j));
            }
            printf("\n");
        }
        printf("\n");
}

Ejercicio 9:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct Articulo Articulo;

struct Articulo{
        long int        id;
        char *          nombre;
        double          precio;
        long int        cantidad;
};

Articulo * articulos;
long int cantidad_articulos=0;
long int capacidad_memoria=0;

void agregar(Articulo * art){
    int i;

    for (i=0; i<cantidad_articulos; i++){
        if (articulos[i].id==art->id){
            printf("ID repetido, no se agrega\n");
            return;
        }
    }

    if ( capacidad_memoria == cantidad_articulos ){
        if ( ! capacidad_memoria )
            capacidad_memoria = 2;
        else
            capacidad_memoria = capacidad_memoria << 1;

        articulos = realloc(articulos, sizeof(Articulo)*capacidad_memoria);
    }

    articulos[cantidad_articulos] = *art;
    cantidad_articulos+=1;
}

int main(void){
        Articulo art, *temp;
        long int id, cantidad;
        double precio;
        char buffer[1000];
        int i;
        printf("Ingrese id, nombre, precio, cantidad. EOF para terminar\n");

        while (1){
                if (scanf(
                        "%ld %s %lf %ld", 
                        &(id), 
                        &(buffer), 
                        &(precio), 
                        &(cantidad)
                    )!=4){
                    printf("FIN\n");
                    break;
                }
                temp=malloc(sizeof(Articulo));
                if (temp==NULL){
                    printf("Error de memoria\n");
                    break;
                }
                temp->id = id;
                temp->nombre = strdup(buffer);
                temp->precio = precio;
                temp->cantidad = cantidad;
                agregar(temp);
        }

        printf("ID\t\tNombre\t\tPrecio\t\tCantidad\t\tCosto Stock\n");
        for (i = 0; i < cantidad_articulos; i++){
            *temp = articulos[i];
            printf("%li\t\t%s\t\t%.2lf\t\t%li\t\t\t%.2lf\n", 
                    temp->id, 
                    temp->nombre, 
                    temp->precio, 
                    temp->cantidad,
                    temp->precio * temp->cantidad);
        }

        return 0;
}

Ejercicio 9:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct Sensor Sensor;
typedef struct Medicion Medicion;

struct Medicion{
    double     valor;
    Medicion * proxima;
    Medicion * previa;
};

struct Sensor{
    char id[3];
    Medicion * primera;
    Medicion * ultima;
    double prom_50;
    double prom_25;
    double prom_5;
};

Sensor * sensores;
long int cantidad_sensores=0;
long int capacidad_memoria=0;

Sensor* getSensor(char* id){
    int i;

    for (i=0; i<cantidad_sensores; i++){
        if (strcmp(sensores[i].id, id)==0){
            return &sensores[i];
        }
    }

    if ( capacidad_memoria == cantidad_sensores ){
        if ( ! capacidad_memoria )
            capacidad_memoria = 2;
        else
            capacidad_memoria = capacidad_memoria << 1;

        sensores = realloc(sensores, sizeof(Sensor)*capacidad_memoria);
    }

    sensores[cantidad_sensores].id[0]=id[0];
    sensores[cantidad_sensores].id[1]=id[1];
    sensores[cantidad_sensores].id[2]=id[2];
    sensores[cantidad_sensores].primera = NULL;
    cantidad_sensores+=1;
    printf("Nuevo ID %s\n", id);
    return &sensores[cantidad_sensores-1];
}

void agregarMedicion(char* id, double value){
    int i = 0;
    Sensor * sensor = getSensor(id);
    Medicion * puntero = sensor->primera;
    Medicion * temp;
    double acu;

    while ( puntero ) { // ir hasta cola de sensado
            i++;
            printf("%.2lf\n", puntero->valor);
            puntero = puntero->proxima;
    }

    printf("Se conocen %d lecturas\n", i);

    if (i > 49){
        printf("Se tienen más de 50 lecturas, sacando: %d\n", 50-i+1);
        temp = sensor->ultima;
        for ( i = 0; i < 49; i++ ){
            if (temp->previa) // proteger por seg faults
                temp = temp->previa;
            else
                break;
        }
        sensor->primera=temp;
    }

    temp = malloc(sizeof(Medicion));
    temp->valor = value;
    temp->previa = sensor->ultima;

    if ( sensor->primera == NULL)
        sensor->primera = temp;

    if (sensor->ultima)
        sensor->ultima->proxima=temp;
    sensor->ultima = temp;

    // verificar últimas 5 mediciones
    acu = 0;
    for (i = 0, temp=sensor->ultima; i<5; i++){
        if (temp)
            acu+=temp->valor;
        else
            break;
        temp=temp->previa;
    }
    sensor->prom_5 = acu/i; // promediar

    // verificar últimas 25 mediciones
    acu = 0;
    for (i = 0, temp=sensor->ultima; i < 25; i++){
        if (temp)
            acu+=temp->valor;
        else
            break;
        temp = temp->previa;
    }
    sensor->prom_25 = acu/i; // promediar

    // verificar últimas 50 mediciones
    acu = 0;
    for (i = 0, temp=sensor->ultima; i < 50; i++){
        if (temp)
            acu+=temp->valor;
        else
            break;
        temp = temp->previa;
    }
    sensor->prom_50 = acu/i; // promediar

    printf("Sensor: %s, Promedios: %.2lf %.2lf %.2lf\n", 
            sensor->id, 
            sensor->prom_5, 
            sensor->prom_25,
            sensor->prom_50);
}

int main(void){
        char id[1000];
        double medicion;
        int i;
        printf("Ingrese id, medicion\n");

        while (1){
                scanf("%s %lf", &id, &medicion);
                if (strlen(id)==0)
                    break;
                agregarMedicion(id, medicion);
                id[0]=0;
        }

        return 0;
}
Posted in c, facultad | Leave a comment

How to get P&E from CodeWarrior installed in Mandriva 2010.1

Ok so here’s the deal, in the university they gave us some devel kits based on several Freescale Microcontrollers (former Motorola), thing is I got Codewarrior 10.0 installed in my Mandriva 2010.1 but I couldn’t get the drivers built correctly.

After reading a few lines of code I figured out how to do it, basically you need to edit a small line:

file: Drivers/pemicro/windriver/redist/configure.wd

Original line (there are a few calls):
echo "#include <linux/utsrelease.h>" > hello.c

New line:
echo "#include <generated/utsrelease.h>" > hello.c
| Leave a comment

Writing a DBus Service

For those who don’t know DBus is a great tool for sharing information between processes inside a Unix system (local only AFAIK). DBus allows the creation of simple processes that communicate with others, so it makes an ideal solution for creating daemons that need to interact with others.

Ok here is a small server:

#! /bin/python

# based on http://dbus.freedesktop.org/doc/dbus-python/doc/tutorial.html

import dbus, dbus.service

BUS_NAME="com.example.DBusService"

class DBusService(dbus.service.Object):
    def __init__(self, object_path=None, bus=None):
        self.bus = bus or dbus.SessionBus()
        self.object_path = object_path or "/dbusservice" 
        self.name = dbus.service.BusName(BUS_NAME, self.bus)
        DBusService.instance = self
        dbus.service.Object.__init__(self, self.bus, self.object_path)
        print "service ready"

    @dbus.service.method(dbus_interface=BUS_NAME,
                         in_signature='v', out_signature='s')
    def toString(self, variant):
        return str(variant)
    
    @dbus.service.method(dbus_interface=BUS_NAME,
                         in_signature='', out_signature='s',
                         sender_keyword='sender')
    def SayHello(self, sender=None):
        return 'Hello, %s!' % sender
    
    @dbus.service.method(dbus_interface=BUS_NAME,
                         in_signature='s', out_signature='')
    def SendAMessage(self, text):
        self.YouHaveAMessage(text)
    
    @dbus.service.signal(dbus_interface=BUS_NAME,
                         signature='s')
    def YouHaveAMessage(self, text):
        print "YouHaveAMessage %s" % text
    
if __name__ == '__main__':
    import gobject
    from dbus.mainloop.glib import DBusGMainLoop
    
    loop = gobject.MainLoop()
    DBusGMainLoop(set_as_default=True)
    
    manager = DBusService()
    loop.run()

And here is a small client that will show how to interface with the previous server:

#! /bin/python

if __name__ == '__main__':
    import dbus, gobject
    
    def sendAMessage():
        print "sending a message"
        iface.SendAMessage("Hello You")
        return False
    
    def callback(*args, **kwargs):
        loop.quit()
        print "callback", args, kwargs
    
    bus = dbus.SessionBus()
    
    proxy = bus.get_object('com.example.DBusService', '/dbusservice')
    iface = dbus.Interface(proxy, dbus_interface='com.example.DBusService')
    
    print iface.toString(1234)
    
    print iface.SayHello()
    
    print "sending a message"
    iface.SendAMessage("hello you")
    
    loop = gobject.MainLoop()
    iface.connect_to_signal("YouHaveAMessage", callback)
    gobject.timeout_add(10, sendAMessage)
    loop.run()
Posted in dbus, python | Leave a comment