Escritura del Framebuffer

Hola a todos. Cuando intento escribir en el framebuffer (/dev/fb0) en ubuntu. Obtengo la siguiente salida:

Violación de segmento ('core' generado).

¿Alguien sabe como escribir en dicho sector de memoria sin obtener ese warning? De manera tal de poder graficar en pantalla.

Para abrir el framebuffer, hago lo siguiente.

Este es el código que intento ejecutar luego de compilar.

PHP:
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <linux/fb.h>
#include <sys/mman.h>
#include <sys/ioctl.h>

int main()
{
    int fbfd = 0;
    struct fb_var_screeninfo vinfo;
    struct fb_fix_screeninfo finfo;
    long int screensize = 0;
    char *fbp = 0;
    int x = 0, y = 0;
    long int location = 0;

    // Open the file for reading and writing
    fbfd = open("/dev/fb0", O_RDWR);
    if (fbfd == -1) {
        perror("Error: cannot open framebuffer device");
        exit(1);
    }
    printf("The framebuffer device was opened successfully.\n");

    // Get fixed screen information
    if (ioctl(fbfd, FBIOGET_FSCREENINFO, &finfo) == -1) {
        perror("Error reading fixed information");
        exit(2);
    }

    // Get variable screen information
    if (ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo) == -1) {
        perror("Error reading variable information");
        exit(3);
    }

    printf("%dx%d, %dbpp\n", vinfo.xres, vinfo.yres, vinfo.bits_per_pixel);

    // Figure out the size of the screen in bytes
    screensize = vinfo.xres * vinfo.yres * vinfo.bits_per_pixel / 8;

    // Map the device to memory
    fbp = (char *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED, fbfd, 0);
    if ((int)fbp == -1) {
        perror("Error: failed to map framebuffer device to memory");
        exit(4);
    }
    printf("The framebuffer device was mapped to memory successfully.\n");

    x = 100; y = 100;       // Where we are going to put the pixel

    // Figure out where in memory to put the pixel
    for (y = 100; y < 300; y++)
        for (x = 100; x < 300; x++) {

            location = (x+vinfo.xoffset) * (vinfo.bits_per_pixel/8) +
                       (y+vinfo.yoffset) * finfo.line_length;

            if (vinfo.bits_per_pixel == 32) {
                *(fbp + location) = 100;        // Some blue
                *(fbp + location + 1) = 15+(x-100)/2;     // A little green
                *(fbp + location + 2) = 200-(y-100)/5;    // A lot of red
                *(fbp + location + 3) = 0;      // No transparency
        //location += 4;
            } else  { //assume 16bpp
                int b = 10;
                int g = (x-100)/6;     // A little green
                int r = 31-(y-100)/16;    // A lot of red
                unsigned short int t = r<<11 | g << 5 | b;
                *((unsigned short int*)(fbp + location)) = t;
            }

        }
    munmap(fbp, screensize);
    close(fbfd);
    return 0;
}
Es la misma salida: Error al intentar abrir el framebuffer device. Permiso denegado.
¿Alguien ha tenido este tipo de problema?
Entiendo que el acceso es denegado por Ubuntu y este problema no lo tendría en un sistema embebido, pero en primera me gustaría probar la codificación en dicho sistema de escritorio antes de llevar esto a otros sistemas.
 
Última edición por un moderador:
Sin tener idea veo que /dev/fb0 tiene permisos 660 y propietario:grupo root:video

Ese programa lo ejecutas como root (sudo) o como un usuario que pertenezca al grupo video?
 
Si lo ejecutas con sudo ya se ejecuta como root

Lo que te dicen esos permisos es que tanto el usuario root como el grupo video tienen permisos de lectura/escritura 6 = rw-

Si quisieses que un usuario "normal" por ejemplo "julian" tuviese esos permisos y no tener que ejecutar como root (con sudo) lo que tienes que hacer es añadir al grupo "video" el usuario "julian". Eso lo puedes hacer mediante el gestor de usuarios, por linea de comando o editando /etc/group

Si con sudo tienes este problema de permisos, lo del grupo tampoco te lo va a resolver. Del tema de programación de framebuffer no tengo ni idea :)
 

Dr. Zoidberg

Well-known-Papá Pitufo
El frame buffer debe estar usado en modo exclusivo por el subsistema grafico de Ubuntu, y si es asi no vas a poder acceder a el en forma directa como intentas hacerlo.

Fijate si te sirve esto: http://tldp.org/HOWTO/Framebuffer-HOWTO/ pero no vas a poder usar el frame buffer si estás usando modo gráfico en Ubuntu...
 
Última edición:
Es posible la escritura del buffer en raspdebian como se puede ver en las imágenes adjuntas. Anteriormente no me era posible por 2 posibles razones.

1-Ubuntu no permitía la escritura del buffer.
2-como corría ubuntu en una máquina virtual, esto impedía la escritura del buffer.
 

Adjuntos

  • IMG_20180117_185034839.jpg
    IMG_20180117_185034839.jpg
    47.5 KB · Visitas: 5
  • IMG_20180117_185458168.jpg
    IMG_20180117_185458168.jpg
    95.7 KB · Visitas: 5
Arriba