DAC MCP4725

Máquina de estados para controlar el MCP4725

Lo siguiente que debemos tener en cuenta es la máquina de estados. Su funcionamiento es relativamente sencillo, ya que el módulo i2c_master se encarga de enviar automáticamente la dirección I²C configurada mediante la señal addr.

Primero ingresamos al estado IDLE, en el cual se implementa un pequeño tiempo de espera después de la energización del sistema. Este tiempo permite que el MCP4725 y los demás componentes se estabilicen antes de iniciar la comunicación.

En nuestro ejemplo se utiliza un tiempo de espera de 100 ms. Debido a que el reloj de la FPGA trabaja a 50 MHz, se necesitan 5 000 000 ciclos de reloj:

localparam int COUNTER_5M   = 5_000_000; // 100 ms
localparam int COUNTER_500K = 500_000;

El estado IDLE se ejecuta solamente una vez después del reinicio. Cuando finaliza el tiempo de espera, la máquina de estados pasa al estado MCP4725_W, encargado de transmitir los bytes de configuración y los datos del DAC.

En el estado MCP4725_W se envían el segundo, tercer y cuarto byte de la trama mostrada en la Figura 6-2 de la hoja de datos. El primer byte, correspondiente a la dirección I²C 0x60, es enviado automáticamente por el módulo i2c_master.

La variable busy_count permite identificar qué byte debe enviarse en cada etapa. El contador aumenta cada vez que la señal busy cambia de cero a uno, indicando que el maestro I²C ha comenzado una nueva transmisión.

always_ff @(posedge clk or negedge reset) begin
    if (!reset) begin
        state      <= IDLE;
        en         <= 1'b0;
        rw         <= 1'b0;
        data_wr    <= 8'h00;
        counter    <= 0;
        busy_count <= 0;
        busy_prev  <= 1'b0;

        // Inicializar los registros en cero

    end else begin
        busy_prev <= busy;

        unique case (state)

            IDLE: begin
                en <= 1'b0;

                if (counter < COUNTER_5M) begin
                    counter <= counter + 1'b1;
                end else begin
                    counter    <= 0;
                    busy_count <= 0;
                    state      <= MCP4725_W;
                end
            end

            MCP4725_W: begin

                if (!busy_prev && busy)
                    busy_count <= busy_count + 1'b1;

                unique case (busy_count)

                    0: begin
                        en      <= 1'b1;
                        rw      <= 1'b0;
                        data_wr <= 8'h40;
                        // Segundo byte:
                        // Write DAC Register
                        // C2 = 0, C1 = 1, C0 = 0
                        // PD1 = 0, PD0 = 0
                    end

                    1: begin
                        en      <= 1'b1;
                        rw      <= 1'b0;
                        data_wr <= onda[11:4];
                        // Tercer byte:
                        // bits D11 hasta D4
                    end

                    2: begin
                        en      <= 1'b1;
                        rw      <= 1'b0;
                        data_wr <= {onda[3:0], 4'b0000};
                        // Cuarto byte:
                        // bits D3 hasta D0
                        // seguidos por cuatro bits Don't Care
                    end

                    3: begin
                        en <= 1'b0;

                        if (!busy) begin
                            busy_count <= 0;
                            state      <= MCP4725_W;
                        end
                    end

                    default: begin
                        en <= 1'b0;
                    end

                endcase
            end

            default: begin
                state <= IDLE;
            end

        endcase
    end
end

En la primera transmisión se envía el valor 0x40, correspondiente al comando Write DAC Register en modo normal. Posteriormente se envían los 12 bits de la señal onda.

El tercer byte contiene los bits D11-D4, mientras que el cuarto byte contiene los bits D3-D0 en su parte superior. Los cuatro bits restantes se rellenan con ceros, ya que son bits Don't Care.