Raspberry Pi como gerador de sinais

No post Transmitindo RF com o Raspberry Pi expliquei como emitir rádio frequência somente com seu Raspberry Pi e transmitir em FM. O controle da frequência como explicado no post é feito controlando um divisor MASH que utiliza uma frequência vinda de um PLL de 500Mhz. O tema desse post é relacionado a algo que já vimos anteriormente, mas com foco diferente. Assim como um DDS, podemos gerar diversas frequências diretamente com o Raspberry Pi e utiliza-las não só para RF, mas também para testes ou clock para outros dispositivos.
O esquema para configurar as frequências utiliza a mesma base utilizada no pifm, mapear /dev/mem na memória e alterar manualmente os valores de controle de clock, divisor e configurar o GPIO4 como ALT0 que é a função alternativa para funcionar como GPCLK0, o output do clock.

Enquanto outros projetos como pifm utilizam somente o PLL de 500Mhz, resolvi testar outras fontes de clock disponíveis, com isso foi possível conseguir frequências de 5Khz à 500Mhz.

As fontes de clock ativas que encontrei em meu Raspberry Pi foram as seguintes:

XTAL 19.2Mhz - Esse é o cristal que fica abaixo da placa.
PLLC 1000Mhz
PLLD 500Mhz
HDMI auxiliary 216Mhz

Outro possível seria o PLLA mas que parece estar inativo.

Algo que descobri ao fazer testes com diversas fontes de clock, foi que o PLLC tinha clock de 1000Mhz, algo que não é citado em referência alguma na internet, as únicas que encontrei eram informações de que possivelmente seriam os clocks de exemplo da página 105 no datasheet do BCM2835.

Para configurar e ativar a frequência utilizaremos o código abaixo. Existe como fazer também pela wiringpi, isso foi adicionado a um tempo, entretanto não é possível a utilização de outras fontes de clock.

Todos os testes foram feitos com a revisão 2.0 da placa.

/*
 *      GPCLK0 Frequency Controller by blog.everpi.net
 *
 */

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

#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <errno.h>

#define MAPSIZE 0x01000000
#define GPF_SEL0 0x200000
#define CM_GP0CTL 0x101070
#define CM_GP0DIV 0x101074

#define CM_GP1CTL 0x101078
#define CM_GP1DIV 0x10107c

#define HELP \
        "\n  \033[1mGPCLK0 Frequency Controller by blog.everpi.net\n\n" \
        "\tUsage: freq_g [frequency] [source]\n\n" \
        "\t\t [frequency] in Mhz with or without float pointing\n" \
        "\t\t [source]    number is the frequency source argument\n\n" \
        "\tSupported sources: 1 - XTAL 19.2Mhz\n" \
        "\t\t\t   5 - PLLC 1000Mhz\n" \
        "\t\t\t   6 - PLLD 500Mhz default\n" \
        "\t\t\t   7 - HDMI aux 216Mhz\033[0m\n\n"

#define _ERR(c) if(c == -1){ fprintf(stderr,"%s\n",strerror(errno)); return 1; }

int main(int argc, char *argv[]){
        
        volatile uint32_t *map = NULL;
        int memfd = 0;  
        int err   = 0;
        float sum = 0;  
        float clock = 0;        

        struct cm_gpctl{
        
                uint32_t src:      4; // Clock source
                uint32_t enab:     1; // Enable the clock generator
                uint32_t kill:     1; // Kill the clock generator
                uint32_t unused:   1; // Unused bit
                uint32_t busy:     1; // Indicates if the clock generator is running
                uint32_t flip:     1; // Invert the clock generator output
                uint32_t mash:     2; // MASH Control
                uint32_t unused2: 13; // Unused bits
                uint32_t passwd:   8; // Clock manager password "0x5a"
        
        }gpctl = { 6,   // src
                   1,   // enab
                   0,   // kill 
                   0,   // unused
                   0,   // busy
                   0,   // flip
                   1,   // mash
                   0,   // unused2
                   0x5a // passwd
        };

        if(argc < 2){
                printf("%s",HELP);
                return 0;
        }
        
        memfd = open("/dev/mem", O_RDWR|O_SYNC);
        _ERR(memfd);
        
        map = (unsigned int *)mmap(NULL,MAPSIZE,PROT_READ|PROT_WRITE,
                                   MAP_SHARED,memfd,0x20000000);
        _ERR((int)map); 
        
        *(volatile uint32_t *)((uint32_t)map+GPF_SEL0 ) &= ~(7 << 12); // clear triple cfg of gpio4
        *(volatile uint32_t *)((uint32_t)map+GPF_SEL0 ) |=  (4 << 12); // set gpio4 to ALT0
        
        
        if(argc > 2){

                gpctl.src = strtol(argv[2],NULL,10);

                switch(gpctl.src){
                        
                        case 1: clock = 19.2; break;   // XTAL
                        case 5: clock = 1000.0; break; // PLLC
                        case 6: clock = 500.0; break;  // PLLD
                        case 7: clock = 216.0; break;  // HDMI auxiliary
                        
                }
        }else{
                clock = 500.0; // PLLD
                gpctl.src = 6;
        }
        
        *(volatile uint32_t *)((uint32_t)map+CM_GP0CTL) = *((int *)&gpctl);     

        printf("%p - %p\n",map,((uint32_t)map+0x101070));
        
        sum = strtod(argv[1],NULL);     
        printf("Frequency:%f\n", sum);
        printf("Normal divisor:%f\n",clock / sum);
        printf("Divisor:%d\n",(int)((clock / sum ) * (float)(1<<12) + 0.5));    
        *(volatile uint32_t *)((uint32_t)map+CM_GP0DIV) = (0x5a << 24) + 
                                                         (int)( (clock / sum ) * 
                                                         (float)(1<<12) + 0.5 );

        err = munmap((uint32_t *)map,MAPSIZE);      
        _ERR(err);
        
        close(memfd);
        _ERR(err);      

        return 0;
}

Salve o código, compile com gcc freq_g.c -o freq_g

Ao rodar o programa sem qualquer argumento é apresentado as seguintes opções: 

#./freq_g

  GPCLK0 Frequency Controller by blog.everpi.net

    Usage: freq_g [frequency] [source]

         [frequency] in Mhz with or without float pointing
         [source]    number is the frequency source argument

    Supported sources:   1 - XTAL 19.2Mhz
                                      5 - PLLC 1000Mhz
                                      6 - PLLD 500Mhz default
                                      7 - HDMI aux 216Mhz


Por padrão é utilizado o PLLD de 500Mhz se nada for especificado no source. Se você quer 433.9Mhz por exemplo, será preciso especificar o uso do PLLC, pois a divisão miníma é por 2, exemplo:

#./freq_g 433.9 5

Algumas observações se fazem necessárias,a precisão dos Khz não será a mesma em todas as frequências, quanto mais baixa em relação ao PLL menor ela será, o valor do divisor contém uma parte inteira e outra em ponto flutuante, entretanto o problema é que a parte do ponto flutuante tem somente 12 bits, dependendo da frequência que necessita, você pode tentar outros PLLs para ver qual chega mais perto.

A menor frequência que consegui por exemplo, foi de 5Khz e somente utilizando como source o XTAL de 19.2Mhz.

Quanto menor a frequência, mais quadrado o sinal irá ficar e vice versa.

Outra questão é nos problemas em relação a vários tipos de ruídos, no final do post Transmitindo RF com o Raspberry Pi apresentei um projeto chamado PiHat de automação residencial usando a frequência de 433.92Mhz, naquele caso o criador se aproveitou da harmônica gerada nessa frequência e criou um filtro para utiliza-la em seu projeto. Além de harmônicas, no uso de certas frequências temos vários tipos de ruídos, como nos exemplos abaixo.

Segundo o datasheet do BCM2835 página 105, um dos efeitos do filtro MASH na frequência está na variação quando utilizado divisores fracionários e que essa variação aumenta quanto menor for o número divisor. A exemplo, utilizando 16Mhz que para ser obtida precisa de um número divisor relativamente grande de 31,25 com PLL de 500Mhz, a frequência foi relativamente estável no osciloscópio, entretanto não tenho em mãos um frequencímetro para testes mais precisos.

No post Controlando módulo DDS AD9850 com Raspberry Pi demonstrei ele sendo usado como gerador de clock para um Atmel retirado do meu arduino, o mesmo pode ser feito com o clock gerado no GPIO4 do Raspberry Pi.

Vimos que o progresso nesse tipo de utilização e frequência não estava estagnado aos 250Mhz, acredito que ainda exista muito a se desenvolver e a tirar do Raspberry Pi.

Referências:
http://www.raspberrypi.org/wp-content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf
http://www.icrobotics.co.uk/wiki/index.php/Turning_the_Raspberry_Pi_Into_an_FM_Transmitter
http://www.skagmo.com/page.php?p=projects/22_pihat

Está gostando do blog? Ajude-nos a divulgar e curta nossa página no Facebook ou siga-nos no Twitter.