TX UART e macchina a stati

[flz47655]

Ciao a tutti,
Per sperimentare con le macchine a stati ho scritto un semplice modulo tx uart ma ho notato che con l'editor visuale di Quartus non è possibile utilizzare dei vettori per gli input, confermate?

Ecco il codice, non ho previsto un segnale di reset ma inizializzo le variabili nella dichiarazione port dell'entity, è una pratica scorretta?

Mi piacerebbe qualche commento che mi "smontasse" il codice che sicuramente è migliorabile.

Il funzionamento è questo: quando voglio trasmettere dei dati preparo un bit in tx_data ed imposto tx_start ad high per iniziare la trasmissione bit dopo bit aggiungendo il segnale di start e due di stop finali. Il segnale tx_busy può essere collegato ad un led e mi avverte che la trasmissione è in corso.

Ho utilizzato una semplice macchina a stati scritta a mano in quanto ho trovato la limitazione sopra descritta utilizzando l'editor visuale, si potrebbe fare anche a meno di una macchina a stati?

Ecco il codice

Code: Select all

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity uart_tx is
   Port(   clock      : in   STD_LOGIC;   -- Baudrate clock
         tx_start   : in   STD_LOGIC   := '0';
         tx_data   : in   STD_LOGIC_vector(7 downto 0)   := B"01001100";
         tx_out   : out   STD_LOGIC;
         tx_busy   : out STD_LOGIC   := '0'
   );   
end uart_tx;

architecture uart_tx_bhv of uart_tx is
   TYPE type_fstate IS (TxStart,BitStart,Bit0,Bit2,Bit1,Bit3,Bit4,Bit5,Bit6,Bit7,BitStop1,BitStop2);
   SIGNAL fstate       : type_fstate    := TxStart;   -- Stato corrente
   SIGNAL reg_fstate : type_fstate   := TxStart;   -- Stato futuro
begin   

-- Ad ogni fronte di clock aggiorna lo stato
PROCESS (clock,reg_fstate)
BEGIN
   IF (clock='1' AND clock'event) THEN
      fstate <= reg_fstate;
   END IF;
END PROCESS;

-- Ad ogni fronte di clock
PROCESS (clock, fstate)
BEGIN
   IF (clock='1' AND clock'event) THEN      
      CASE fstate IS
         -- Se tx_start='1' e lo stato è idle
         -- (TxStart) inizia a spedire i dati sequenzialmente
         WHEN TxStart =>
            IF (tx_start='1') THEN
               reg_fstate <= BitStart;
            END IF;
            tx_out <= '1'; -- Line idle
            tx_busy <= '0';
         WHEN BitStart =>
            tx_out <= '1';
            tx_busy <= '1';
            reg_fstate <= Bit0;
         WHEN Bit0 =>            
            tx_out <= tx_data(0);   
            reg_fstate <= Bit1;               
         WHEN Bit1 =>
            tx_out <= tx_data(1);
            reg_fstate <= Bit2;
         WHEN Bit2 =>
            tx_out <= tx_data(2);
            reg_fstate <= Bit3;
         WHEN Bit3 =>
            tx_out <= tx_data(3);
            reg_fstate <= Bit4;
         WHEN Bit4 =>
            tx_out <= tx_data(4);
            reg_fstate <= Bit5;
         WHEN Bit5 =>
            tx_out <= tx_data(5);
            reg_fstate <= Bit6;
         WHEN Bit6 =>
            tx_out <= tx_data(6);
            reg_fstate <= Bit7;
         WHEN Bit7 =>
            tx_out <= tx_data(7);
            reg_fstate <= BitStop1;
         WHEN BitStop1 =>
            tx_out <= '1';
            reg_fstate <= BitStop2;
         WHEN BitStop2 =>
            tx_out <= '1';
            reg_fstate <= TxStart;
         WHEN OTHERS =>
            reg_fstate <= TxStart;
   END CASE;
   END IF;
END PROCESS;   
end uart_tx_bhv;

Ciao

[deluca]

Il codice si presenta abbastanza leggibile e chiaro... (non l'ho testato... ma mi sembra funzionante )
si tratta di un buon inizio per studiare le macchine a stati.
(secondo la letteratura, per questo tipo di periferiche l'unica strada è l'FSM)

Comq, è bene inserire sempre un segnale di reset in tutti i moduli in cui è presente un process;
questo ti permetterà di sincronizzarli se ne avrai di bisogno ad esempio se controlli il tutto con un micro int/ext.

Il prossimo passo potrebbe essere quello di creare un modulo RX ed infine potrestii arricchire l'hardware con 2 FIFO in RX e TX di qualche centinaio di byte. I segnali in uscita che non devono mancare sono almeno 2 e sono FIFO_FULL e FIFO_EMPTY.

Poi se inserisci un registro a 16bit per la configurazione dinamica del baudrate non sarebbe male.

Ciao....

Sarebbe cosa interessante veder pubblicato il lavoro nel forum.
Sarebbe un utile aiuto per tutti gli utenti neofiti.

[flz47655]

Grazie per la risposta,

A breve aggiungerò il reset allora, nel frattempo mi sono arrivati anche i moduli UART->USB e sembrano funzionare molto bene ( gli ho provati per il momento con un AtMega328p)

Il percorso che voglio svolgere è proprio questo, fare un pezzetto alla volta per realizzare un modulo UART completo, magari non sarà rifinito come quelli di OpenCores ma perlomeno lo avrò fatto io e avrò imparato qualcosa nella realizzazione.

L'idea è anche quella di condividere il mio viaggio pubblicando i risultati e scrivendo dei tutorial o degli articoli per permettere ad altri avventurosi di evitare gli errori che ho fatto e imparare nuove nozioni e allo stesso tempo per permettere ai più esperti di darmi delle dritte.

A presto
Ciao

[flz47655]

Ho trovato un bug, il bit di start deve essere uno 0 e non un 1, semplice la correzione:
WHEN BitStart => tx_out <= '0';

Ho notato poi che UART prevede un invio "alla rovescia" del byte, ho quindi corretto il carattere "L" invertendo i bit.

Volevo porre invece una domanda che mi è sorta:

Ho creato come top level un diagramma a blocchi (ho sostituito alcuni segnali di input/output con dei segnali interni ai blocchi e quindi non si vedono nello schema):


Nel pin planner però vengono mostrati con mia sorpresa anche i segnali collegati nel diagramma ma con direzione "unknow"



Cosa vuol dire? devo assegnare ugualmente dei pin anche a questi segnali o vengono assegnati automaticamente?

Di default come standard I/O Quartus mi presentava 2.5V che ho modificato a 3.3-V LVTTL perchè in futuro vorrei collegare la FPGA ad una MCU a 3.3 volt (vedi http://www.delucagiovanni.com/public/phpbb3/viewtopic.php?f=11&t=247) anche se per il momento mi accontento di collegare la FPGA al PC tramite un modulo USB->Seriale (http://www.aliexpress.com/product-gs/492071325-CP2102-Serial-Converter-USB-2-0-To-TTL-UART-6PIN-Module-OT814-wholesalers.html) che vorrei collegare al PC per leggere su console il carattere "L" trasmesso dalla FPGA in continuazione.

Il modulo USB con il chip CP2102 http://www.silabs.com/Support%20Documents/TechnicalDocs/cp2102.pdf dispone dei pin RST, 3V3, 5V, TXD, RXD e GND. Mi basterebbe collegare TXD e GND o rischio in qualche modo di avere altri problemi? Con l'RS232 si parlava di problemi di loop di massa, in questo caso potrebbero esserci?

Non sono un esperto di loop di massa, ho letto solamente http://www.bsproj.it/index.php?option=com_content&view=article&id=59:ground-loops-e-ronzii-come-eliminarli&catid=48:elettronica-generale&Itemid=66 per il momento

Ciao e grazie a tutti

[deluca]

Ciao,

Come tutte le uscite TXD delle UART dei micro, nonchè gli ingressi RXD sono attivi bassi,
quindi dove hai un 1 logico significa che la tensione sarà (ZERO) e vice versa.
Quindi realizzando qualsiasi interfaccia TTL-232 o bisogna attenersi a questo standard elettrico.

Significa che normalmente la linea TXD è a livello logico alto (3.3V), non appena si presenta il bit di start
la linea va bassa ed inizia la trasmissione dei bit...)

Ciao

[Tedesco]

Ciao a tutti.

In VHDL è importante che tutti i processi siano sempre sincroni con il clock ed asincroni con il reset, evitando di inserire nella sensitivity list segnali generati dagli stessi process o da altri process. Le eccezioni ovviamente ci sono ma devono essere tenute sotto controllo in quanto si possono generare dei loop indesiderati.
Il reset potrebbe esserti anche utile in caso di debug, in quanto con un pulsante o DIP switch (che hai sulla De0-nano, ce l'ho anche io ....) puoi resettare la logica senza dovere per forza spegnere la board.
In questo caso per i processi ti consiglio di scrivere:

Code: Select all

TX:process(resetN,clk)
begin
   if resetN_i='0' then
            // stato di reset dei segnali//
        elsif clk'event and clk='1' then
           // tutta la macchina a stati//
        end if;
end process;


Leggendo velocemnte la tua macchina a mi sembra di notare che ogni bit che porti fuori dalla seriale in effetti dura 2 colpi di clock. Lo volevi così?
Questo è dovuto al fatto che hai scritto due processi, uno per lo stato attuale e uno per lo stato futuro.
Cmq, a prescindere ti consiglio di scrivere tutto in un'unico processo, tipo questo nel tuo caso:

Code: Select all

architecture uart_tx_bhv of uart_tx is
   TYPE type_fstate IS (TxStart,BitStart,Bit0,Bit2,Bit1,Bit3,Bit4,Bit5,Bit6,Bit7,BitStop1,BitStop2);
   --SIGNAL fstate       : type_fstate    := TxStart;   -- Stato corrente
   SIGNAL reg_fstate : type_fstate   := TxStart;   -- Stato futuro
begin   

 --Ad ogni fronte di clock aggiorna lo stato
--PROCESS (clock,reg_fstate)
--BEGIN
--   IF (clock='1' AND clock'event) THEN
--      fstate <= reg_fstate;
--   END IF;
--END PROCESS;

-- Ad ogni fronte di clock
PROCESS (clock, reg_fstate)
BEGIN
   IF (clock='1' AND clock'event) THEN     
      CASE reg_fstate IS
         -- Se tx_start='1' e lo stato è idle
         -- (TxStart) inizia a spedire i dati sequenzialmente
         WHEN TxStart =>
            IF (tx_start='1') THEN
               reg_fstate <= BitStart;
            END IF;
            tx_out <= '1'; -- Line idle
            tx_busy <= '0';
         WHEN BitStart =>
            tx_out <= '1';
            tx_busy <= '1';
            reg_fstate <= Bit0;
         WHEN Bit0 =>           
            tx_out <= tx_data(0);   
            reg_fstate <= Bit1;


Ora confronta quello che ottiene con questo process nello State Machine Viewer di Quartus e confrontalo con il tuo di prima, vedrai che hai semplificato notevolmente la macchina a stati.
Volendolo poi ottimizzare potresti pensare di scrivere in questo modo:

Code: Select all

WHEN TxStart =>
            IF (tx_start='1') THEN
               reg_fstate <= BitStart;
            END IF;
            tx_out <= '1'; -- Line idle
            tx_busy <= '0';
         WHEN BitStart =>
            tx_out <= '1';
            tx_busy <= '1';
            reg_fstate <= TX_bit;
         when TX_bit =>
         if i_counter<=6 then
            i_counter   <= i_counter +1;
            tx_out       <= tx_data(i_counter);
            reg_fstate <= TX_bit; 
         else
            i_counter   <= 0;
            tx_out       <= tx_data(i_counter);
            reg_fstate <= BitStop1;
         end if;
         
       WHEN BitStop1 =>
            tx_out <= '1';
            reg_fstate <= BitStop2;


Alla fine gli stati bit0...bit7 fanno sempre la stessa cosa. Ti conviene ricontrollarlo perchè l'ho buttato giù velocemente e senza provarlo).
Ovviamente nelle bozze che ti ho invitato dovrai inserire quel discorso del reset.

Per quanto riguarda il collegamento con il pc mi viene da pensare che di solito la comunicazione tra pc e una seriale Hw (o su logica) si instaura mediante un handshaking, quindi il driver del pc dovrebbe tentare di scrivere e leggere alcuni registri, e se non li trova non avvia la comunicazione. Informati bene.

Per i problemi che hai nel pin planner devi andare ad eliminare manualmente le righe nel file .qsf creato da QuartusII riguardanti i due segnali che ti riguardano (troverai tipo "set_location_assignment PIN_XX").

Un saluto a tutti.

[flz47655]

Ciao Tedesco,
Ti ringrazio moltissimo per le dritte che mi hai dato

Modificando il file .qsf ho risolto il problema e i segnali in più sono spariti, era un pò difficile da risolvere se non me lo dicevi

Appena ho un pochino di tempo però provo ad applicare con calma tutti i consigli sul codice VHDL.

Per la comunicazione col PC ho installato i driver del convertitore e sembra funzionare senza problemi da una prova che ho fatto con Arduino generando il segnale di uscita (che sarà generato via hw dalla FPGA) via software. C'è da settare i corretti parametri nel programma che legge la comunicazione seriale (baudrate,bit parità,etc..) ma poi funziona correttamente data la natura asincrona della comunicazione seriale.

Diciamo che sono fortunato se hai anche tu la DE0-Nano , è molto che lavori con le FPGA?

Ciao e Grazie

[deluca]

Salve ragazzi,
Vi volevo fare un regalino a proposito di uart.
Di seguito il sorgente di una uart che realizzai un bel pò di anni fa per comunicare con i registri di una FPGA attraverso la seriale del PC.
La uart è dotata di RXD, TXD, bus RX e TX a 8 bit, e di tutti i segnali di controllo necessari per interfacciarla direttamente ad un micro
controllore. E' possibile, eventualmente, mappare in memoria il modulo e gestirlo attraverso i segnali uart_write, uart_read e uart_control secondo questa struttura :

Code: Select all

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_unsigned.all;
-------------------------------------------------------------------
entity my_uart is
  port (
    reset  : in std_logic;
    clk    : in std_logic;
    clk_ref : in std_logic;

    uart_data_in : in std_logic_vector( 7 downto 0 );
    uart_data_out : out std_logic_vector( 7 downto 0 );
    uart_control : in std_logic;

    txd : out std_logic;
    rxd : in std_logic;

    ti : out std_logic;
    ri : out std_logic;

    uart_read : in std_logic;
    uart_write : in std_logic
    );
end my_uart;
--------------------------------------------------------------------
architecture behavioral of my_uart is
  signal tx_buffer : std_logic_vector( 7 downto 0 );
  signal tx_ready : std_logic;
  signal itx_baud_clk : std_logic;
  signal itx_busy : std_logic;
  signal iti : std_logic;

  signal rx_baud_clk : std_logic;
  signal rx_buffer : std_logic_vector( 7 downto 0 );
  signal rx_start : std_logic;
  signal irx_ready : std_logic;
  signal iri : std_logic;
begin

  ti <= iti;
  ri <= iri;

---------------------------------------------------------------------------
--                        BAUD Generator
---------------------------------------------------------------------------
process( clk_ref, reset )
    variable rxcnt : integer range 0 to 28;
  begin
    if reset = '1' then
      rxcnt := 0;
      rx_baud_clk <= '0';
    elsif rising_edge(clk_ref) then
      if rxcnt = 28 then
        rxcnt := 0;
        rx_baud_clk <= '1';
      else
        rxcnt := rxcnt + 1;
        rx_baud_clk <= '0';
      end if;
    end if;
  end process;
----------------------------------------------------------------------------
process( clk_ref, rx_baud_clk, reset )
    variable txcnt : integer range 0 to 5;
  begin
    if reset = '1' then
      txcnt := 0;
      itx_baud_clk <= '0';
    elsif rising_edge(clk_ref) then
      if rx_baud_clk = '1' then
        if txcnt = 5 then
          txcnt := 0;
          itx_baud_clk <= '1';
        else
          txcnt := txcnt + 1;
          itx_baud_clk <= '0';
        end if;
      else
        itx_baud_clk <= '0';
      end if;
    end if;
  end process;
---------------------------------------------------------------------------
--                    UART  SFR                     
---------------------------------------------------------------------------
process( clk, uart_control, uart_read, uart_write, tx_ready, reset )
  begin
    if reset = '1' then
      itx_busy <= '0';
      iri <= '0';
      iti <= '0';
    elsif rising_edge(clk) then

      if tx_ready = '1' then
        iti <= '1';
        itx_busy <= '0';
      end if;
      if irx_ready = '1' then
        iri <= '1';
      end if;
      if uart_control = '1' then

        if uart_write = '1' then
          iri <= uart_data_in(0);
          iti <= uart_data_in(1);
        end if;
        if uart_read = '1' then
          uart_data_out <= "000000" & iti & iri;
        end if;
      else

        if uart_write = '1' then
          tx_buffer <= uart_data_in;
          itx_busy <= '1';
        end if;
        if uart_read = '1' then
          uart_data_out <= rx_buffer;
        end if;
      end if;
    end if;
  end process;
---------------------------------------------------------------------------
--                         UART Transmitter                 
---------------------------------------------------------------------------
process( clk_ref, itx_baud_clk, tx_buffer, itx_busy, reset )
    variable state : integer range 0 to 12;
  begin
    if reset = '1' then
      state := 0;
      txd <= '1';
    elsif rising_edge(clk_ref) then
      case state is
     
      when 0 =>
        txd <= '1';
        if (itx_busy = '1') AND (itx_baud_clk = '1') then
          state := 1;
        end if;
        if tx_ready = '1' then
          tx_ready <= '0';
        end if;
      ----------------- qui inizia l'FSM
      when 1 =>
        -- Start bit
        txd <= '0';
        if itx_baud_clk = '1' then
          state := 2;
        end if;
     
      when 2 =>
        -- Bit 0
        txd <= tx_buffer(0);
        if itx_baud_clk = '1' then
          state := 3;
        end if;
     
      when 3 =>
        -- Bit 1
        txd <= tx_buffer(1);
        if itx_baud_clk = '1' then
          state := 4;
        end if;
     
      when 4 =>
        -- Bit 2
        txd <= tx_buffer(2);
        if itx_baud_clk = '1' then
          state := 5;
        end if;
     
      when 5 =>
        -- Bit 3
        txd <= tx_buffer(3);
        if itx_baud_clk = '1' then
          state := 6;
        end if;
     
      when 6 =>
        -- Bit 4
        txd <= tx_buffer(4);
        if itx_baud_clk = '1' then
          state := 7;
        end if;
     
      when 7 =>
        -- Bit 5
        txd <= tx_buffer(5);
        if itx_baud_clk = '1' then
          state := 8;
        end if;
     
      when 8 =>
        -- Bit 6
        txd <= tx_buffer(6);
        if itx_baud_clk = '1' then
          state := 9;
        end if;
     
      when 9 =>
        -- Bit 7
        txd <= tx_buffer(7);
        if itx_baud_clk = '1' then
          state := 10;
        end if;
     
      when 10 =>
        txd <= '1';
        if itx_baud_clk = '1' then
          state := 11;
        end if;
     
      when 11 =>
        txd <= '1';
        if itx_baud_clk = '1' then
          state := 12;
        end if;
     
      when others =>
        txd <= '1';
        tx_ready <= '1';
        if itx_busy = '0' then
          state := 0;
        end if;
      end case;
    end if;
  end process;

---------------------------------------------------------------------------
--                           UART Receive 
---------------------------------------------------------------------------
process( clk_ref, reset )
    variable state : integer range 0 to 12;
    variable sample : std_logic_vector(2 downto 0);
  begin
    if reset = '1' then
      state := 0;
      rx_start <= '0';
    elsif rising_edge(clk_ref) then
      case state is
     
      when 0 =>
        if (rx_baud_clk = '1') and (rxd = '0') then
          state := 1;
          sample := "001";
        end if;
     
      when 1 | 2 | 3 | 4 =>
        if rx_baud_clk = '1' then
          if rxd = '0' then
            sample := sample + 1;
          end if;
          state := state + 1;
        end if;
     
      when 5 =>
        if rx_baud_clk = '1' then
          if rxd = '0' then
            sample := sample + 1;
          end if;
          if sample(2) = '1' then
       
            rx_start <= '1';
            state := 6;
          else
           
            state := 0;
          end if;
        end if;
     
      when others =>
        if irx_ready = '1' then
          rx_start <= '0';
          state := 0;
        end if;
      end case;
    end if;
  end process;
------------------------------------------------------------------
--                       RX data
------------------------------------------------------------------
process( clk_ref, reset )
    variable bitcnt : integer range 0 to 7;
    variable bitsamplecnt : integer range 0 to 5;
    variable samples : std_logic_vector(2 downto 0);
 
  begin
    if reset = '1' then
      rx_buffer <= (others => '0');
      bitcnt := 0;
      bitsamplecnt := 0;
      samples := (others => '0');
    elsif rising_edge(clk_ref) then
      if rx_start = '1' then
        if (irx_ready = '0') AND (rx_baud_clk = '1') then
          if rxd = '1' then
            samples := samples + 1;
          end if;
          if bitsamplecnt = 5 then
            bitsamplecnt := 0;
            rx_buffer <= samples(2) & rx_buffer(7 downto 1);
            samples := (others => '0');
            if bitcnt = 7 then
              bitcnt := 0;
              irx_ready <= '1';
            else
              bitcnt := bitcnt + 1;
            end if;
          else
            bitsamplecnt := bitsamplecnt + 1;
          end if;
        end if;
      else
        bitcnt := 0;
        bitsamplecnt := 0;
        samples := (others => '0');
        irx_ready <= '0';
      end if;
    end if;
  end process;
end behavioral;
-------------------------------------------------------------------


[flz47655]

Grazie Giovanni,

Ho dato un'occhiata veloce al codice ed ho notato che a differenza di come avrei fatto io è strutturato tutto in una sola entity con tanti processi.
Io avrei creato una entity per generare il clock, una per tx, una per rx, etc.. è in qualche modo più vantaggioso avere meno Entity o è solamente una "distinzione concettuale" che si può gestire a proprio piacimento?

Studierò con calma il tuo codice e lo userò come riferimento ma continuerò anche a scrivere la mia versione per scopi didattici

Ciao e grazie

[Tedesco]

Ciao flz

mi fa piacere che ti sia stato d'aiuto sul pin planner.
Saranno ormai un 4 anni che lavoro con FPGA.
La De0-nano l'ho comprata l'anno scorso e l'ho accesa solo i primi giorni. Mi sono tolto solo lo sfizio di implementare un NiosII e di legarlo ad una semplice logica esterna (tipo pigiata di pulsante) che generasse interrupt sul micro stesso. Tutto gestito da un piccolo SW in C++ sul NiosII.
Poi più nulla, dovrò rispolverarla cmq.....

Grazie a deluca x il codice.......interessante!...

Un saluto, e scusate il ritardo

[flz47655]

Stasera ho avuto un pochino di tempo per controllare la macchina a stati che avevo scritto e... in effetti ogni bit dura 2 colpi di clock grazie a Tedesco per la segnalazione

In pratica i due process non lavorano bene perché quando un process imposta il segnale "fstate" la modifica non diviene attiva subito e l'altro process esegue il case sbagliato.

Il classico errore da principiante probabilmente, provo a ripassare meglio i process e poi sistemo il codice coi vostri consigli

Grazie a tutti

@Tedesco: Sai per caso che tipo di connettore esterno ha la DE0-Nano? Ho visto che si può alimentare anche senza USB ma senza il connettore..

Ciao

[Tedesco]

Ciao

purtroppo non conosco il connettore, e adesso che mi ci hai fatto pensare su alcuni forum ho letto (ormai a suo tempo) che qualcuno si è ritrovato con la USB del PC fuori uso dopo un pà che usava la De0-nano.....
Certo, tutto dipende da quello che chiedi alla scheda, e forse è il caso di stare attenti...
Quindi se riesci ad alimentarlo esternamente è meglio....

Ciao

[deluca]

Ciao Tedesco,
quando dici che lavori con le fpga cosa intendi ?
Lavori per una azienda privata o che altro ?

Sviluppi solo VHDL o hai a che fare con le problematiche hw delle fpga (tipo PCB, signal integrity) ?

Sono curioso, poichè sono pochissime le aziende in Italia che sviluppano progetti su fpga di un certo tipo.
Purtroppo noi in INFN siamo costretti a sviluppare tutto in casa... anche le schede che mandiamo nello spazio o
quelle che stanno al Cern per LHC.

Ciao e grazie per il supporto.

[Tedesco]

Ciao deluca

intendevo sviluppo di logiche su FPGA in VHDL/Verilog. Raramente invece mi capita di occuparmi di PCB.
Sono un consulente ed è un bellissimo lavoro, peccato però che le aziende non hanno molta intenzione di investire in innovazione, cosi preferiscono sempre soluzioni a uP (già super rodate) piuttosto che soft uP e FPGA magari anche a riduzione costi....
Quindi questo settore purtroppo rimane sempre di nicchia, e lo si vede anche da quante info girano sull'argomento nei forum in italiano, a parte questo ora...
Vabbè, si va avanti cmq

Ho visto sul sito che ti occupi di tantissime cose.
Hai modo di spaziare tra vari argomenti e problematiche, quindi molto interessante...
Piacerebbe anche a me fare altro ogni tanto...
Buon lavoro allora...:D

A presto.
Ciao:D

[legacy]

Sono un consulente ed è un bellissimo lavoro

Consulente ottimo lavoro ? Bah ...

[Tedesco]

Ciao legacy,

poco fà sono entrato ne forum ed ho letto quello che avevi appena scritto rigurado la mia espressione:

"Sono un consulente ed è un bellissimo lavoro"........

Ma avevi scritto un papiro!!...
Perchè hai cancellato tutto ed hai lasciato solo la prima riga?? Ti stavo rispondendo!!.........
Anche se però ti eri risposto da solo, cioè che è tutto soggettivo, no?....

Ciao.....

[flz47655]

Ciao a tutti,
Per non scordare quel pochino che avevo imparato di VHDL stasera ho ridato un'occhiatina al mio modulino UART TX ed ho deciso di iniziare a scrivere anche il ricevitore UART RX..
Mi è venuto un dubbio, se il bit di stop non viene letto si va incontro ad un cosidetto Framing error ma non ho trovato cosa dicono le specifiche del protocollo RS-232 su come proseguire da questa situazione, sembra che ci sia abbastanza "anarchia", io avevo pensato ad aspettare che la linea rimanesse in Idle per almeno 2 periodi (Stop1, Stop2) per poi ricominciare normalmente la lettura.
Voi come gestite in genere questa situazione?