Текст программ на языке VHDL для калибровки цифрового трёхосного MEMS акселерометра

Размещено на http://allbest.ru

Текст программ на языке VHDL для калибровки цифрового трёхосного MEMS акселерометра

Аннотация к программе

акселерометр калибровка цифровой программа

В документе представлены программы, необходимые для правильной работы устройства калибровки цифрового акселерометра и реализующие обмен данными по протоколу SPI между акселерометром и ПЛИС, а так же RS-232 для передачи данных с макета на ПЭВМ.

Программа позволяет выполнять инициализацию MEMS-акселерометра, принимать от него байты данных соответствующие текущему угловому состоянию датчика и его ускорению.

Программа разработана в среде Quartus II Software Version 9.0. Для ее функционирования требуется наличие на компьютере операционной системы Windows XP/Vista/7.

1. SPI-Master

--объявление пакета(собственной библиотеки)

package spi_pack is

type spi_states is (sleep, init, rw, iready, status); --iwait --ЦКА

subtype byte is natural range 0 to 255;

--регистр управления режимами работы по мощности и частотой вывода данных(дискретизации)

Constant BW_RATE: byte := 44;

--регистр управления спящим режимом и частотой показаний в спящем режиме

Constant POWER_CTRL: byte := 45;

--регистр управления прерыванием

Constant INT_ENABLE: byte := 46;

--регистр управления логическим уровнем прерывания, выравниванием бит данных и разрядностью

Constant DATA_FORMAT: byte := 49;

--готовность передачи

Constant Status_REG: byte := 48;

--ускорение акселерометра по трем осям чувствительности

Constant DATA_X0: byte := 50;

--частота дискретизации 100Гц, нормальный режим работы (по мощности)

Constant BW_RATE_WORD: byte := 10;--14;--12

--нормальный режим работы, режим измерения

Constant POWER_CTRL_WORD: byte := 8;

--прерывание разрешено

Constant INT_ENABLE_WORD: byte := 128;

--диапазон измеряемых ускорений _ ±4g, выравнивание бит - по левому краю, 11 разрядов

Constant DATA_FORMAT_WORD: byte := 13;

--кол-во инициализируемых регистров

Constant all_init_regs: byte := 4;

--кол-во читаемых регистров(по 2 байта на каждую ось чувствительности)

Constant all_read_regs: byte := 6;

type gyro_regs is array (0 to all_init_regs-1) of byte;

Constant init_addreses: gyro_regs := (BW_RATE, POWER_CTRL, INT_ENABLE,DATA_FORMAT);

Constant ctrl_data: gyro_regs := (BW_RATE_WORD, POWER_CTRL_WORD, INT_ENABLE_WORD, DATA_FORMAT_WORD);

--количество тактовых импульсов(частота дискретизации)1МГЦ/100Гц

Constant Discrete: natural range 0 to 16_383 := 10_000;--1_000_000/625 ;--10_000 -- 2500

end spi_pack;

--объявление библиотек

library ieee;

use ieee.std_logic_1164.all;

use ieee.std_logic_arith.all;

use ieee.std_logic_unsigned.all;

use work.spi_pack.all;

entity spi_core is

port

(

--сигнал разрешения передачи данных (передача по низкому логическому уровню)

cs: out std_logic;

--тактовый сигнал

scl: out std_logic;

--выходной сигнал SPI для подачи на вход акселерометра

sdi: out std_logic;

--входящий высокочастотный сигнал

clock: in std_logic;

--входной сигнал SPI для чтения данных с выхода SDO акселерометра

sdo: in std_logic;

--биты данных для одной оси чувчтвительности

data_out: out std_logic_vector(15 downto 0);

--выход передачи UART

tx: out std_logic;

--вход приема UART

rx: in std_logic

);

end spi_core;

architecture Behavior of spi_core is

--делитель

Component divider is

--настроечная константа

generic (N : natural := 8);

port

(

--тактовый сигнал

clk : in std_logic;

--сигнал сброса

reset: in std_logic;

--сигналы установки и чтения по разным фронтам

clk_out: out std_LOGIC;

clk_scl: out std_LOGIC

);

end Component;

--передатчик

Component tx_uart is

generic

(

--скорость передачи

Rapid: natural := 115_200;

--частота дискретизации

Fd: natural := 100;

--кол-во передаваемых байт по умолчанию

n_bytes: natural := 6

);

port

(

--тактовый высокочастотный сигнал

clock : in std_logic;

--сигнал сброса

rst : in std_logic;

--массив бит входных данных длиной 8*кол-во байт

data_tx: in std_logic_vector(8*n_bytes - 1 downto 0);

--выход UART

tx: out std_LOGIC

);

end Component;

type gyro_reads is array (0 to all_read_regs-1) of std_logic_vector(7 downto 0);

signal new_data, new_data_temp, init_ready, rst: std_logic;

signal clk, clk_for_scl, scl_ena: std_logic;

signal wd: std_logic;

signal n_bit: natural range 0 to 8*(all_read_regs + 1) -1;

signal num_init: natural range 0 to all_init_regs;

signal num_read: natural range 0 to all_read_regs;

signal D_out: gyro_reads;

signal ready: std_logic;

signal data_tx: std_logic_vector(8*all_read_regs - 1 downto 0);

signal cnt: std_logic;

signal state, next_state: spi_states;

begin

Div_freq: divider generic map (N => 24) port map (clock, '1', clk, clk_for_scl);

process (state, wd, init_ready, n_bit, new_data, num_read)

begin

case (state) is

when sleep => if (init_ready = '0') then next_state <= init;

elsif (wd = '1') then next_state <= status;

elsif (new_data = '1') then next_state <= rw;

else next_state <= sleep;

end if;

when init => if (n_bit = 15)

then next_state <= sleep;

else next_state <= init;

end if;

when status => if (n_bit = 15)

then next_state <= sleep;

else next_state <= status;

end if;

when rw => if (n_bit = (8*(all_read_regs + 1) -1))

then next_state <= iready;

else next_state <= rw;

end if;

when iready => next_state <= sleep;

when others => null;

end case;

end process;

process (clk, cnt)

begin

if (cnt = '0') then n_bit <= 0;

elsif (clk'event and clk = '0') then

n_bit <= n_bit + 1;

end if;

end process;

process (clk)

variable cycle: natural range 0 to Discrete;

begin

if (clk'event and clk = '0') then

state <= next_state;

if cycle = 0

then wd <= '1';

else wd <= '0';

end if;

if cycle = Discrete - 1

then cycle := 0;

else cycle := cycle + 1;

end if;

end if;

end process;

process (clock, state, n_bit, num_init, num_read)

variable cycle: natural range 0 to Discrete;

variable data: std_logic_vector(15 downto 0);

begin

if (clock'event and clock = '1') then

case (state) is

when sleep => sdi <= '0';

cs <= '1';

scl_ena <= '0';

cnt <= '0';

when init => cs <= '0';

scl_ena <= '1';

data := "00" & conv_std_logic_vector(init_addreses(num_init), 6) & conv_std_logic_vector(ctrl_data(num_init), 8);

sdi <= data(15 - n_bit);

cnt <= '1';

when status => cs <= '0';

scl_ena <= '1';

data := "10" & conv_std_logic_vector(Status_REG, 6) & "11111111";

sdi <= data(15 - n_bit);

cnt <= '1';

when rw => cs <= '0';

scl_ena <= '1';

data := "11" & conv_std_logic_vector(DATA_X0, 6) & "11111111";

if (n_bit < 16) then

sdi <= data(15 - n_bit);

else

sdi <= '1';

end if;

cnt <= '1';

when iready => cs <= '1';

scl_ena <= '0';

sdi <= '0';

cnt <= '0';

when others => null;

end case;

end if;

end process;

process (clk, state, n_bit, new_data)

variable data: gyro_reads;

begin

if (clk'event and clk = '0') then

case (state) is

when sleep => num_read <= 0;

when init => if (n_bit = 15) then

if (num_init = all_init_regs - 1)

then init_ready <= '1';

else init_ready <= '0';

num_init <= num_init + 1;

end if;

end if;

when status => if (n_bit = 8)

then new_data <= sdo;

end if;

when rw => if (n_bit > 7)

then data(num_read)(7 - (n_bit rem 8)) := sdo;

if (n_bit rem 8 = 7)

then num_read <= num_read + 1;

end if;

end if;

when iready => data_out <= data(1) & data(0);

new_data <= '0';

data_tx <= data(1) & data(0) & data(3) & data(2) & data(5) & data(4);

when others => null;

end case;

end if;

end process;

scl <= '1' when scl_ena = '0' else clk_for_scl;

Tx_UART_Tx: tx_uart generic map (Rapid => 460_800,

Fd => 100,

n_bytes => all_read_regs)

port map

(

clock => clock,

rst => not rx,

data_tx => data_tx,

tx => tx

);

end Behavior;

2. Параметрический делитель частоты с асинхронным сбросом

library IEEE;

use IEEE.std_logic_1164.all;

use IEEE.std_logic_arith.all;

use IEEE.std_logic_unsigned.all;

entity divider is

generic (N : natural);

port

(

clk : in std_logic;

reset: in std_logic;

--rx: in std_logic;

clk_out: out std_LOGIC;

clk_scl: out std_LOGIC

);

end divider;

architecture behavior of divider is

begin

process (clk, reset)

variable cnt: natural := 0;

begin

if (reset = '0') then

cnt := 0; clk_out <= '0'; clk_scl <= '0';

elsif (clk'event and clk = '1') then

case cnt is

when 0 => clk_out <= '0'; clk_scl <= '1';

when N/2 => clk_out <= '1'; clk_scl <= '0';

when others => null;

end case;

if cnt = N -1 then cnt := 0;

else cnt := cnt + 1;

end if;

end if;

end process;

end behavior;

1.3 Передатчик UART

package UART_settings is

Constant Freq: natural := 24_000_000;

end package;

library IEEE;

use IEEE.std_logic_1164.all;

use IEEE.std_logic_arith.all;

use IEEE.std_logic_unsigned.all;

use work.UART_settings.all;

entity tx_uart is

generic

(

Rapid: natural := 115_200;

Fd: natural := 100;

n_bytes: natural := 6

--parity: parity_bit := no

);

port

(

clock : in std_logic;

data_tx: in std_logic_vector(8*n_bytes - 1 downto 0);

tx: out std_LOGIC

);

end tx_uart;

architecture Behavior of tx_uart is

component divider is

generic (N : natural);

port

(

clk : in std_logic;

reset: in std_logic;

clk_out: out std_LOGIC

);

end component;

Constant Discr: natural := Rapid/Fd;

type UART_states is (sleep, start, dtx, stop);

signal state, next_state: UART_states := sleep;

signal clk: std_logic;

signal counter: natural range 0 to 15;

signal cnt: std_logic;

signal period: std_logic;

signal sent: std_logic;

signal num: natural range 0 to n_bytes;

begin

div: divider generic map (N => Freq/Rapid) port map (clock, '1', clk);

process(clock, state, num)

variable data: std_logic_vector(8*n_bytes - 1 downto 0);

begin

if (clock'event and clock = '1') then

case (state) is

when(sleep) => tx <= '1';

cnt <= '0';

sent <= '0';

when start=> tx <= '0';

sent <= '0';

cnt <= '0';

if (num = 0)

then data := data_tx;

end if;

when stop => tx <= '1';

cnt <= '0';

sent <= '1';

when dtx => cnt <= '1';

sent <= '0';

if counter /=8 then

tx <= data(8*(n_bytes - num) - 8 + counter);

else tx <= data(8*(n_bytes - num) - 1) xor data(8*(n_bytes - num) - 2) xor

data(8*(n_bytes - num) - 3) xor data(8*(n_bytes - num) - 4) xor

data(8*(n_bytes - num) - 5) xor data(8*(n_bytes - num) - 6) xor

data(8*(n_bytes - num) - 7) xor data(8*(n_bytes - num) - 8) xor '1';

end if;

when others => null;

end case;

end if;

end process;

process(state, num, counter, period)

begin

case (state) is

when(sleep) => if period = '1' then next_state <= start;

else next_state <= sleep;

end if;

when start=> next_state <= dtx;

when stop => if (num = n_bytes) then

next_state <= sleep;

else

next_state <= start;

end if;

when dtx =>if (counter) = 7 then --no

--if (counter) = 8 then -- even or odd

next_state <= stop;

else next_state <= dtx;

end if;

when others => null;

end case;

end process;

process (clk, cnt)

begin

if (cnt = '0') then counter <= 0;

elsif (clk'event and clk = '0') then

counter <= counter + 1;

end if;

end process;

process (sent, period)

begin

if (period = '1') then num <= 0;

elsif (sent'event and sent = '1') then

if num = n_bytes then

num <= 0;

else

num <= num + 1;

end if;

end if;

end process;

process (clk)

variable cycle: natural range 0 to Discr;

begin

if (clk'event and clk = '0') then

state <= next_state;

if cycle = 0

then period <= '1';

else period <= '0';

end if;

if cycle = Discr - 1

then cycle := 0;

else cycle := cycle + 1;

end if;

end if;

end process;

end Behavior;

Размещено на Allbest.ru