mirroring
/
logisim
mirror of https://github.com/lawrancej/logisim.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Addressing several integration issues with the Portuguese translation - notably, changing the file encoding on HTML files to UTF-8. 

git-svn-id: https://circuit.svn.sourceforge.net/svnroot/circuit/trunk@170 70edf91d-0b9e-4248-82e7-2488d7716404
This commit is contained in:
Carl Burch 2010-12-16 19:57:30 +00:00
parent 8bf4c64f9d
commit 43dc0f3e25
147 changed files with 10758 additions and 10968 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
doc/pt/html/JavaHelpSearch/DOCS
View File

Binary file not shown.

4
doc/pt/html/JavaHelpSearch/DOCS.TAB
View File

@ -1,4 +0,0 @@
eЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪщЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪuЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪщЪЪЪЪЪЪЪЪЩвЪЪЪЪЪЪЪВ_ЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪВ_ЪЪЪЪЪЪЪЪЪЪЪЪЪЩвЪЪЪЪЪщЪЪЪЪЪЪЪЪЪЪЪЪЪЩувЪЪЪЪЪЪЪЪЪЩвЪЪЪЪЪЪЪЪЪЩвЪЪЪЪЪЩувЪЪЪЪЪЪЪЩвЪЪЪЪЪЪЪЪЪЪЪЪuЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪuЪЪЪЪЪЪЪВ_ЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЩвЪЪЪЪЪЪЪЪЪЪЪЪЪuЪЪЪЪЪщЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЩвЪЪЪЪЪЪЪЪЪЪщЪЪЪuЪЪЪЪЪuЪЩвЪЪЪЪЩвщЪЪЪЪЪщЪЩвЪЪЪЪЪЪЪЪЪЪЪЩвЪЪЪЪЪЪЪЪЪЪЩвuЪЪЪЪЪЪЪщЪЪЪЪЪЪЪЪuЪЪВ_ЪЪЪЪЪЪЩвuЪЪВ_ЪЪЪЪЪЪЪЪЪЪuЪuЪЪЪЪЪЪЩвЪЪЪЭрЪЪЪЪЪЪЪЪЪЪЪВ_ЪЪЪuЪВ_ЪЪЪЪЪЩвЪщЪЪЪЪщЪЪЪЪЪЪЪЪщЪЪЪЪЪЪЪЪЪЪЪЪВ_щЪЪЩвЪЪВ_ЪuЪЪЪuЪЩвЪЪЪuЪuЪЪЩвuЪЪщЪЪЪЪВ_ЪЪЪЪЪЪЪЩвЪЪЪЪЪЪuЪЪЪЪuЪЪЪщЪЪuЪЪЪЪВ_ЪЪщЪЩвВ_В_ЪuЪЪЪЪЪuЪЪЪВ_ЪЪuЪЪЪЪЪЪЪЪЪЪЩвЪЪuЪuЪЪЩУЪЪЩвЩвЪВ_м'ЪЪЪuВ_ЪЪuuЪЪЪВ_В]вЩЩЪЪЪЪЩвЪuЪЪ}ЪЪЪЪЪЪu}ЪЪЩвЪЪЪЪЪВ_В_ЪщЪщ]]ЪЪщ4÷ЪЪЪЪщЪЪСиЪЪuuЪ_В_п╜щlл┼ЁК╡╙╙╙╙╙╙╘╣kИ┘j÷┘Ид╟х⌠И┘├!:;(4#ё╒#ре*╙╝╤╥Эг M Р╜тЙ╙ЙЙ≥4╨"╜ёr╔L1`■Ь▀+ з"╙ёrL╕▓л7'ййй╨╙╙uJщa*М╛╛;.1'e,3#lл▒ЕLH╚R╗УBZф╫>╙╜╛з▓╔╚{J≤J╞kЙ╨╬╗ю┴д·2"╖e*i/╕╜╕рмй╨ц"&Е,2.Q┘*╝╥зXД┼Ёэ└╙КьZ²╓⌡J╝╫∙╚O⌠$Врё",gт╙╜iz╙╛м3*O*·QхWн┬╙╬ы*aF■фр}7Жуe*mFRЩi.╝╚йm.0"Зйш╙╕R╙╙лйaJ╖Rз╜╙a#бТ╙╘у+YJ╙╙╙╙▄┴*╩КX6"╛╫йв╛Гр╛ЙqJ2"aJй╕рa#▓╔╘┬M■╢п⌡Н╙╚*╚5╬J╚.К/2╙╡╣└╙╨ЙН╙л╗у╒*╙╙╙2,?"╙c╞R╜╕▓g√╛Л╙з╙з╪╙╙цmк╙л╪╛╨╙╙й╙╙╙╙З╨ё>╙╕тллллйqV!*З╙1▓}й╙╙й╛y,e&■йЩ6"╙╙в╙ёrz╙╪╨╙╙╕"рМa*╖╙▐Rl┼╙╙╙╙╙╙╟у╡Gв╙ё,╙ЗfуФ≈q*Ф√╬ёТ≤$hЮ╙agс6&q7Ы.╜йЙ<+е╘е·Q▀WL'ж╖║Kf■з5*OН╗Д║*╬aFжT:#ц╓э"╜зkbт╖TeL0"dч Ж╚ьJ·3"╚╙╤МG▓╝1┌VSГRc▄╚k~ОZJЙ╗Л∙■╚≤у╜ЕЁi╢эK_[╦п⌠ыS]уo╘┐b|8D▓▄кaL╛кй╛╨╙оaFRмuzО╙й╜eOК0"шз╙╝о╝Йa*Чa+лЗ╥pю⌠К>²у}┴R╚Oи2ыK+W╞vК>▄┬©2 Е  K╩ и/0П╔Lгумс┌7∙ж▓hд┴╔2╡╩)┴1"kel╕}&√aF∙q[фЫ;з╤R╜a\╚╕UфЯ,фTоЖ JсrFR╞ц:чйhю ▄IСЫе5уШR╩щPН
%~лЪ0&a&pэ╬з╝j▓энлМ╪йолъжRй╞йa*Ъ╞ЙМЛЗг!lй╙ф╙щйЙмо}F!*Лul╫╜ф▄
e.a,╛╙й╨╙╛ЙзaM╙╙╙мщb■╫СRKщш╩л╩лл╩╩МnэлллЛкк╤■╩╪©╩╩╫╬╩╩╩╩╩╤╤Иk╪╩╩╩╩Эк╩╤Sк╩ллк╩╩╩кк╩╩╩╩╪╫╩л╩q\╩Н╩╩ъqF∙╩╩╫к╩╬╩╩╩e[╩╩╩к╪╩╩╩╩к╩╩Ш╩╩╩╩╩╩╩╪╩╫кк╩╪╪╩akкл╩╩╫╩╪i6э╪лкк╩чк╩╩╬©шш╩╩u;╩╩╩╩к╫фM,⌠Md∙∙7╝В.НМУmдМ╓НННРНО:шZВЁ2О/тО.РРШНННУТСwnННОnННОnРУ└ННО╡ННРНО.ННО≥у//6л NЗННННРННыNННО.ЖьO.НРНРМ∙2ЪnМ╨NОsRННВы_rНС.Я■ННРыNьOnО.ВС╜┘/≤NНЪXMе/y╦W?/╥nЧЫ■РНС7lю▐ЪnзRО┘Щ┘.ьNРННРРНО.зNНМ└Му7ННОrЪ╡РШ╝НЧнРНО1┬RЪ╝ННО╝ННЖННННННЧНЗННО.НРО6С6НО╝НСs.О;╞6эW7s.О3.ьSSСRРШS.С3rС2В.РНННО2ОnРРНРВzНС3/.ьNНРО/2О/ ┬СРыO3//.ОrНС/╬РРОw?╠■НРСrВ2НПл·О.НС╞:ЧО╡РС2О32РС.РНРРНС.ННзNНННННСrНО>ННО.НО.РНННРРНО.НННС//nРЖэ∙2ЪNРС.РЗЖННО;2ННЖО.РННННРНС╝НэOnНьNРНО.РНННО32О3.НННС.ННРОnННЧННННРННЗОЁ2ЧНРЖС32НЖНО.В2РНО-└ЧНННО.О2РЖНННРННОННО.НРНРНННННО/{НННС.РС3СVЖРРНОs3╝НО/2НННННННННО.НО.ННННННННЖНО/╝ОnНННЗС2Вл
VФ╩Л╩e;╪эъ╩л╩╩╩╪╩╩шщ╫╪╫э╩╫к╩╩э╪кщщ╩╩к╩╩лл╩╪╩к╩╩╩╩╩╩╪╩╩╩╩╩╩╩╩©©м╩шв╪щэкк╬лэмм╫Ф╔l╪ллмм╩ллмш╩╩╪ш╩╫М╩╩╩╩╩╩╩к╫╩╩╬©╪ЖН╩╩╩╩╫╩кк╪╩╩ш╩╩к╩╩к╩╩╩╩╩╪лк╩эллш╩к╩╩╩шк╩╫╩╩╫╩╩╩╩╩╩╩╩╪кщМщк╩╪лкМ╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩╩К╩лк╪Кн╩╩╪©К╩╩╩╩╩╫╩╩╩эОлЭл╩╪ш╩╩╬м╩╬К╩кл╩╩╩╩к╩╩╩к╩╩╩╩╩╩╩╩╩╩╩╩╬Лклк╩╩╩╩╩╩@

BIN
doc/pt/html/JavaHelpSearch/OFFSETS
View File

Binary file not shown.

BIN
doc/pt/html/JavaHelpSearch/POSITIONS
View File

Binary file not shown.

2
doc/pt/html/JavaHelpSearch/SCHEMA
View File

@ -1,2 +0,0 @@
JavaSearch 1.0
TMAP bs=2048 rt=1 fl=-1 id1=3578 id2=1

BIN
doc/pt/html/JavaHelpSearch/TMAP
View File

Binary file not shown.

0
doc/pt/html/comp.properties
View File

70
doc/pt/html/contents.html
View File

@ -1,15 +1,15 @@
<?xml version='1.0' encoding='UTF-8' ?>
<toc version="2.0" categoryclosedimage="chapter" topicimage="topic">
<h1><a image="toplevelfolder" id="top">Referências do Logisim</a></h1>
<h1><a image="toplevelfolder" id="top">Referências do Logisim</a></h1>
<h2><a id="guide">Guia para se tornar usuário do Logisim</a></h2>
<h2><a id="guide">Guia para se tornar usuário do Logisim</a></h2>
<ul>
<li><a id="tutorial">Tutorial para o iniciante</a><ul>
<li><a id="tutorial_orient">Passo 0: Para orientar-se</a></li>
<li><a id="tutorial_gates">Passo 1: Para acrescentar portas</a></li>
<li><a id="tutorial_wires">Passo 2: Para acrescentar conexões</a></li>
<li><a id="tutorial_wires">Passo 2: Para acrescentar conexões</a></li>
<li><a id="tutorial_text">Passo 3: Para acrescentar texto</a></li>
<li><a id="tutorial_test">Passo 4: Para testar seu circuito</a></li>
</ul></li>
@ -21,44 +21,44 @@
<li><a id="subcirc">Subcircuitos</a><ul>
<li><a id="subcirc_creating">Para criar circuitos</a></li>
<li><a id="subcirc_using">Para usar subcircuitos</a></li>
<li><a id="subcirc_appear">Para editar a aparência de subcircuito</a></li>
<li><a id="subcirc_appear">Para editar a aparência de subcircuito</a></li>
<li><a id="subcirc_debug">Para depurar subcircuitos</a></li>
<li><a id="subcirc_library">Bibliotecas do Logisim</a></li>
</ul></li>
<li><a id="bundles">Conexões</a><ul>
<li><a id="bundles_creating">Para criar conexões</a></li>
<li><a id="bundles">Conexões</a><ul>
<li><a id="bundles_creating">Para criar conexões</a></li>
<li><a id="bundles_splitting">Distribuidores</a></li>
<li><a id="bundles_colors">Cores das conexões</a></li>
<li><a id="bundles_colors">Cores das conexões</a></li>
</ul></li>
<li><a id="analyze">Análise combinacional</a><ul>
<li><a id="analyze_open">Para abrir a Análise Combinacional</a></li>
<li><a id="analyze">Análise combinacional</a><ul>
<li><a id="analyze_open">Para abrir a Análise Combinacional</a></li>
<li><a id="analyze_table">Para editar a tabela-verdade</a></li>
<li><a id="analyze_expr">Para criar expressões</a></li>
<li><a id="analyze_expr">Para criar expressões</a></li>
<li><a id="analyze_gen">Para gerar um circuito</a></li>
</ul></li>
<li><a id="menu">Referência para menus</a><ul>
<li><a id="menu">Referência para menus</a><ul>
<li><a id="menu_file">O menu Arquivo</a></li>
<li><a id="menu_edit">O menu Editar</a></li>
<li><a id="menu_project">O menu Projeto</a></li>
<li><a id="menu_simulate">O menu Simular</a></li>
<li><a id="menu_winhelp">Os menus Janela e Ajuda</a></li>
</ul></li>
<li><a id="mem_guide">Componentes de memória</a><ul>
<li><a id="mem_poke">Para testar memória</a></li>
<li><a id="mem_guide">Componentes de memória</a><ul>
<li><a id="mem_poke">Para testar memória</a></li>
<li><a id="mem_menu">Menus pop-up e arquivos</a></li>
<li><a id="mem_hex">Editor hexadecimal</a></li>
</ul></li>
<li><a id="log">Registro</a><ul>
<li><a id="log_selection">A aba Seleção</a></li>
<li><a id="log_selection">A aba Seleção</a></li>
<li><a id="log_table">A aba Tabela</a></li>
<li><a id="log_file">A aba Arquivo</a></li>
</ul></li>
<li><a id="verify">Verificação por linha de comando</a><ul>
<li><a id="verify">Verificação por linha de comando</a><ul>
<li><a id="verify_sub">Para substituir bibliotecas</a></li>
<li><a id="verify_other">Outras opções para verificação</a></li>
<li><a id="verify_multi">Para testar vários arquivos</a></li>
<li><a id="verify_other">Outras opções para verificação</a></li>
<li><a id="verify_multi">Para testar vários arquivos</a></li>
</ul></li>
<li><a id="prefs">Preferências para a aplicação</a><ul>
<li><a id="prefs">Preferências para a aplicação</a><ul>
<li><a id="prefs_template">A aba Gabarito</a></li>
<li><a id="prefs_intl">A aba Internacional</a></li>
<li><a id="prefs_window">A aba Janela</a></li>
@ -66,22 +66,22 @@
<li><a id="prefs_exp">A aba Experimental</a></li>
<li><a id="prefs_cmdline">A linha de comando</a></li>
</ul></li>
<li><a id="opts">Opções de projeto</a>
<li><a id="opts_simulate">A aba Simulação</a></li>
<li><a id="opts">Opções de projeto</a>
<li><a id="opts_simulate">A aba Simulação</a></li>
<li><a id="opts_toolbar">A aba Ferramentas</a></li>
<li><a id="opts_mouse">A aba Mouse</a></li>
</ul></li>
<li><a id="prop">Propagação de sinal</a><ul>
<li><a id="prop">Propagação de sinal</a><ul>
<li><a id="prop_delays">Atrasos de portas</a></li>
<li><a id="prop_oscillate">Erros de oscilação</a></li>
<li><a id="prop_shortcome">Deficiências</a></li>
<li><a id="prop_oscillate">Erros de oscilação</a></li>
<li><a id="prop_shortcome">Deficiências</a></li>
</ul></li>
<li><a id="jar">Bibliotecas JAR</a><ul>
<li><a id="jar_incr">Incrementador em código de Gray</a></li>
<li><a id="jar_incr">Incrementador em código de Gray</a></li>
<li><a id="jar_library">Classe Biblioteca</a></li>
<li><a id="jar_simpctr">Contador simples em código de Gray</a></li>
<li><a id="jar_counter">Contador em código de Gray</a></li>
<li><a id="jar_guide">Orientações</a></li>
<li><a id="jar_simpctr">Contador simples em código de Gray</a></li>
<li><a id="jar_counter">Contador em código de Gray</a></li>
<li><a id="jar_guide">Orientações</a></li>
</ul></li>
<li><a id="about">Sobre o programa</a><ul>
<li><a id="about_gpl">GNU General Public License</a></li>
@ -89,7 +89,7 @@
</ul>
<h2><a id="libs">Referências para bibliotecas</a></h2>
<h2><a id="libs">Referências para bibliotecas</a></h2>
<ul>
<li><a id="base">Biblioteca Base</a><ul>
@ -101,7 +101,7 @@
<li><a id="base_menu">Ferramenta Menu</a></li>
<li><a id="base_splitter">Distribuidor</a></li>
<li><a id="base_pin">Pino</a></li>
<li><a id="base_tunnel">Túnel</a></li>
<li><a id="base_tunnel">Túnel</a></li>
<li><a id="base_pull">Resistor para ajuste</a></li>
<li><a id="base_probe">Ponta de prova</a></li>
<li><a id="base_clock">Clock</a></li>
@ -113,7 +113,7 @@
<li><a id="gates_not">Porta NOT</a></li>
<li><a id="gates_buffer">Buffer</a></li>
<li><a id="gates_basic">Portas AND/OR/NAND/NOR</a></li>
<li><a id="gates_xor">Portas XOR/XNOR/Paridade par/ímpar</a></li>
<li><a id="gates_xor">Portas XOR/XNOR/Paridade par/ímpar</a></li>
<li><a id="gates_controlled">Buffer/Inversor controlado</a></li>
</ul></li>
<li><a id="plexers">Biblioteca Plexers</a><ul>
@ -123,7 +123,7 @@
<li><a id="plexers_priencod">Codificador de prioridades</a></li>
<li><a id="plexers_selector">Seletor de bits</a></li>
</ul></li>
<li><a id="arith">Biblioteca Aritmética</a><ul>
<li><a id="arith">Biblioteca Aritmética</a><ul>
<li><a id="arith_adder">Somador</a></li>
<li><a id="arith_subtractor">Subtrator</a></li>
<li><a id="arith_multiplier">Multiplicador</a></li>
@ -134,17 +134,17 @@
<li><a id="arith_bitadder">Contador de bits</a></li>
<li><a id="arith_bitfinder">Indexador de bits</a></li>
</ul></li>
<li><a id="mem">Biblioteca Memória</a><ul>
<li><a id="mem">Biblioteca Memória</a><ul>
<li><a id="mem_flipflops">Flip-Flop D/T/J-K/S-R</a></li>
<li><a id="mem_register">Registrador</a></li>
<li><a id="mem_counter">Contador</a></li>
<li><a id="mem_shiftreg">Registrador de deslocamento</a></li>
<li><a id="mem_random">Gerador aleatório</a></li>
<li><a id="mem_random">Gerador aleatório</a></li>
<li><a id="mem_ram">RAM</a></li>
<li><a id="mem_rom">ROM</a></li>
</ul></li>
<li><a id="io">Biblioteca Entrada/Saída</a><ul>
<li><a id="io_button">Botão</a></li>
<li><a id="io">Biblioteca Entrada/Saída</a><ul>
<li><a id="io_button">Botão</a></li>
<li><a id="io_joystick">Joystick</a></li>
<li><a id="io_keyboard">Teclado</a></li>
<li><a id="io_led">LED</a></li>

69
doc/pt/html/doc.hs
View File

@ -1,69 +0,0 @@
<?xml version='1.0' encoding='ISO-8859-1' ?>
<!DOCTYPE helpset
PUBLIC "-//Sun Microsystems Inc.//DTD JavaHelp HelpSet Version 2.0//EN"
"http://java.sun.com/products/javahelp/helpset_2_0.dtd">
<helpset version="2.0">
<!-- title -->
<title>Logisim - Help</title>
<!-- maps -->
<maps>
<homeID>top</homeID>
<mapref location="map.jhm" />
</maps>
<!-- views -->
<view xml:lang="en" mergetype="javax.help.UniteAppendMerge">
<name>TOC</name>
<label>Table Of Contents</label>
<type>javax.help.TOCView</type>
<data>contents.xml</data>
</view>
<view>
<name>Search</name>
<label>Search</label>
<type>javax.help.SearchView</type>
<data engine="com.sun.java.help.search.DefaultSearchEngine">
JavaHelpSearch
</data>
</view>
<view>
<name>Favorites</name>
<label>Favorites</label>
<type>javax.help.FavoritesView</type>
</view>
<!-- presentation windows -->
<!-- This window is the default one for the helpset.
* Its title bar says "Logisim Help". It
* is a tri-paned window because displayviews, not
* defined, defaults to true and because a toolbar is defined.
* The toolbar has a back arrow, a forward arrow, and
* a home button that has a user-defined image.
-->
<presentation default=true>
<name>main window</name>
<size width="900" height="700" />
<location x="200" y="10" />
<title>Logisim Help</title>
<toolbar>
<helpaction>javax.help.BackAction</helpaction>
<helpaction>javax.help.ForwardAction</helpaction>
<helpaction image="homeicon">javax.help.HomeAction</helpaction>
<helpaction>javax.help.SeparatorAction</helpaction>
<helpaction>javax.help.FavoritesAction</helpaction>
</toolbar>
</presentation>
<!-- implementation section -->
<impl>
<helpsetregistry helpbrokerclass="javax.help.DefaultHelpBroker" />
<viewerregistry viewertype="text/html"
viewerclass="com.sun.java.help.impl.CustomKit" />
<viewerregistry viewertype="text/xml"
viewerclass="com.sun.java.help.impl.CustomXMLKit" />
</impl>
</helpset>

578
doc/pt/html/guide/about/gpl.html
View File

@ -1,290 +1,290 @@
<html>
<head>
<title>Sobre o programa</title>
</head>
<body bgcolor="FFFFFF">
<pre>
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
</pre>
</body>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Sobre o programa</title>
</head>
<body bgcolor="FFFFFF">
<pre>
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
</pre>
</body>
</html>

234
doc/pt/html/guide/about/index.html
View File

@ -1,117 +1,117 @@
<html>
<head>
<title>Sobre o programa</title>
</head>
<body bgcolor="FFFFFF">
<h1> Sobre o programa </h1>
<p> O Logisim é um programa de código aberto. O código-fonte está incluído
na pasta <code>src</code> contida no arquivo JAR. </p>
<p> Se você considerar o Logisim útil, por favor me avise. <em> Principalmente </em>
se você estiver ligado a uma instituição de ensino, pois suas informações poderão
me ajudar na obtenção de maior apoio para manter esse trabalho.
</p>
<center> <img src="mail.png" width="165" height="18"> </center>
<p> Agradeço o envio de emails sobre Logisim, que incluam relatórios de bugs, sugestões,
e correções. Quando você me enviar algum, por favor, esteja ciente de que tenho
trabalhado duro para manter o Logisim sem qualquer ônus da sua parte. Se você quiser ter
o direito de reclamar sobre o programa, então sugiro direcionar seu orçamento para
programas concorrentes do Logisim. (Não conheço outro com código aberto que seja tão
rico em recursos como o Logisim). No entanto, mantenho meu interesse em continuar a
melhorar o Logisim e suas sugestões serão muito bem-vindas.
</p>
<h2>Comunicação de direitos autorais</h2>
<p>Copyright (c) 2005, Carl Burch.</p>
<p>O Logisim é um programa gratuito; poderá ser redistribuído e/ou modificado
sob os termos da <a href="gpl.html">GNU General Public License</a>
como publicada pela Free Software Foundation; quer seja na versão 2 dessa
licença, ou qualquer outra posterior.
</p>
<p>O Logisim é distribuído na intenção de que possa ser útil,
mas SEM QUALQUER GARANTIAS; nem mesmo aquela implícita para
COMERCIALIZAÇÃO ou ADEQUAÇÃO PARA UM DETERMINADO PROPÓSITO.
Favor consultar a GNU General Public License para maiores detalhes.</p>
<h2> Agradecimentos </h2>
<p> O código fonte do Logisim é basicamente trabalho meu, devo
agradecer meus empregadores por financiar minhas atividades como professor,
dentre elas o desenvolvimento desse programa: o qual iniciei, na Saint John's
University (Collegeville, Minnesota, EUA) em 2000-2004, e tenho mantido
no Hendrix College (Conway, Arkansas, EUA) desde 2004 até
o presente. Sou muito grato a essas instituições por me conceder
tempo e recursos para trabalhar nesse projeto. Tomara todas as faculdades
e universidades pudessem agir em conjunto e serem tão zelosas com o
ensino quanto essas excelentes instituições o fazem! </p>
<p> Algumas outras pessoas têm sido particularmente úteis: </p>
<ul>
<li> Ilia Lilov, Pablo Leal Ramos, e Uwe Zimmermann, que contribuíram
com as traduções que acompanham o Logisim. Mais informações sobre as traduções
podem ser encontrados em <a href="../prefs/intl.html">International Preferences</a>.
<li> A turma CS61C da Primavera de 2005 na Universidade da Califórnia, Berkeley,
que experimentou as versões beta do Logisim 2.0. Esses alunos tiveram que lidar com
<em> muitos </em> erros, e eu estou <strong> muito </strong> grato pela sua
paciência e por suas sugestões! </li>
<li> As turmas CSCI 150 da Primavera de 2001 no College of Saint Benedict e na
Saint John's University, que usaram as versões mais rudimentares de Logisim
enquanto ainda estava sendo desenvolvido. </li>
</ul>
<p> Diversas partes do Logisim têm origem em outros programas; e várias dessas
partes são distribuídas como parte do mesmo:
</p>
<dl>
<dt> Java API da Sun (obviamente) </dt>
<dt> Sun projeto JavaHelp </dt>
<dd> Fornece o sistema integrado no menu Ajuda. </dd>
<dt> MRJAdapter, de Steve Roy </dt>
<dd> Fornece a integração com a plataforma Macintosh OS X. </dd>
<dt> launch4j, de Grzegorz Kowalt </dt>
<dd> Permite a distribuição de Logisim como um executável do Windows. </dd>
<dt> GIFEncoder, desde Adão Doppelt </dt>
<dd> Salva imagens como arquivos GIF. Isso foi feito com base no código C
escrito por Sverre H. Huseby. </dd>
<dt> ColorPicker, de Jeremy Wood </dt>
<dd> Fornece a caixa de diálogo que aparece quando da configuração de cores
(como acontece com o componente LED). </dd>
<dt> JFontChooser, de Christos Bohoris </dt>
<dd> Fornece a fonte da caixa de diálogo que aparece ao selecionar os atributos
de fonte (como o "Label Font" dos rótulos de muitos componentes). </dd>
<dt> TableSorter, atribuído a Philip Milne, McLean Brendon, Dan van Enckevort,
Parwinder Sekhon e ouroborus@ouroborus.org </dt>
<dd> Oferece a capacidade de ordenar a tabela no diálogo
<q>Obter Estatísticas do Circuito </q> ao clicar o cabeçalho de cada colunas.</dd>
</dl>
<p> E finalmente, quero agradecer a todos os usuários que entraram em contato comigo -
quer seja pelo envio de relatórios de bugs, sugestões, ou apenas para me dizer
como estão usando o Logisim em suas aulas. Devo deixar essas contribuições
anônimas, já que não tenho permissão para mencioná-las aqui, mas de qualquer forma:
obrigado! </p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Sobre o programa</title>
</head>
<body bgcolor="FFFFFF">
<h1> Sobre o programa </h1>
<p> O Logisim é um programa de código aberto. O código-fonte está incluído
na pasta <code>src</code> contida no arquivo JAR. </p>
<p> Se você considerar o Logisim útil, por favor me avise. <em> Principalmente </em>
se você estiver ligado a uma instituição de ensino, pois suas informações poderão
me ajudar na obtenção de maior apoio para manter esse trabalho.
</p>
<center> <img src="mail.png" width="165" height="18"> </center>
<p> Agradeço o envio de emails sobre Logisim, que incluam relatórios de bugs, sugestões,
e correções. Quando você me enviar algum, por favor, esteja ciente de que tenho
trabalhado duro para manter o Logisim sem qualquer ônus da sua parte. Se você quiser ter
o direito de reclamar sobre o programa, então sugiro direcionar seu orçamento para
programas concorrentes do Logisim. (Não conheço outro com código aberto que seja tão
rico em recursos como o Logisim). No entanto, mantenho meu interesse em continuar a
melhorar o Logisim e suas sugestões serão muito bem-vindas.
</p>
<h2>Comunicação de direitos autorais</h2>
<p>Copyright (c) 2005, Carl Burch.</p>
<p>O Logisim é um programa gratuito; poderá ser redistribuído e/ou modificado
sob os termos da <a href="gpl.html">GNU General Public License</a>
como publicada pela Free Software Foundation; quer seja na versão 2 dessa
licença, ou qualquer outra posterior.
</p>
<p>O Logisim é distribuído na intenção de que possa ser útil,
mas SEM QUALQUER GARANTIAS; nem mesmo aquela implícita para
COMERCIALIZAÇÃO ou ADEQUAÇÃO PARA UM DETERMINADO PROPÓSITO.
Favor consultar a GNU General Public License para maiores detalhes.</p>
<h2> Agradecimentos </h2>
<p> O código fonte do Logisim é basicamente trabalho meu, devo
agradecer meus empregadores por financiar minhas atividades como professor,
dentre elas o desenvolvimento desse programa: o qual iniciei, na Saint John's
University (Collegeville, Minnesota, EUA) em 2000-2004, e tenho mantido
no Hendrix College (Conway, Arkansas, EUA) desde 2004 até
o presente. Sou muito grato a essas instituições por me conceder
tempo e recursos para trabalhar nesse projeto. Tomara todas as faculdades
e universidades pudessem agir em conjunto e serem tão zelosas com o
ensino quanto essas excelentes instituições o fazem! </p>
<p> Algumas outras pessoas têm sido particularmente úteis: </p>
<ul>
<li> Ilia Lilov, Pablo Leal Ramos, e Uwe Zimmermann, que contribuíram
com as traduções que acompanham o Logisim. Mais informações sobre as traduções
podem ser encontrados em <a href="../prefs/intl.html">International Preferences</a>.
<li> A turma CS61C da Primavera de 2005 na Universidade da Califórnia, Berkeley,
que experimentou as versões beta do Logisim 2.0. Esses alunos tiveram que lidar com
<em> muitos </em> erros, e eu estou <strong> muito </strong> grato pela sua
paciência e por suas sugestões! </li>
<li> As turmas CSCI 150 da Primavera de 2001 no College of Saint Benedict e na
Saint John's University, que usaram as versões mais rudimentares de Logisim
enquanto ainda estava sendo desenvolvido. </li>
</ul>
<p> Diversas partes do Logisim têm origem em outros programas; e várias dessas
partes são distribuídas como parte do mesmo:
</p>
<dl>
<dt> Java API da Sun (obviamente) </dt>
<dt> Sun projeto JavaHelp </dt>
<dd> Fornece o sistema integrado no menu Ajuda. </dd>
<dt> MRJAdapter, de Steve Roy </dt>
<dd> Fornece a integração com a plataforma Macintosh OS X. </dd>
<dt> launch4j, de Grzegorz Kowalt </dt>
<dd> Permite a distribuição de Logisim como um executável do Windows. </dd>
<dt> GIFEncoder, desde Adão Doppelt </dt>
<dd> Salva imagens como arquivos GIF. Isso foi feito com base no código C
escrito por Sverre H. Huseby. </dd>
<dt> ColorPicker, de Jeremy Wood </dt>
<dd> Fornece a caixa de diálogo que aparece quando da configuração de cores
(como acontece com o componente LED). </dd>
<dt> JFontChooser, de Christos Bohoris </dt>
<dd> Fornece a fonte da caixa de diálogo que aparece ao selecionar os atributos
de fonte (como o "Label Font" dos rótulos de muitos componentes). </dd>
<dt> TableSorter, atribuído a Philip Milne, McLean Brendon, Dan van Enckevort,
Parwinder Sekhon e ouroborus@ouroborus.org </dt>
<dd> Oferece a capacidade de ordenar a tabela no diálogo
<q>Obter Estatísticas do Circuito </q> ao clicar o cabeçalho de cada colunas.</dd>
</dl>
<p> E finalmente, quero agradecer a todos os usuários que entraram em contato comigo -
quer seja pelo envio de relatórios de bugs, sugestões, ou apenas para me dizer
como estão usando o Logisim em suas aulas. Devo deixar essas contribuições
anônimas, já que não tenho permissão para mencioná-las aqui, mas de qualquer forma:
obrigado! </p>
</body>
</html>

238
doc/pt/html/guide/analyze/expr.html
View File

@ -1,119 +1,119 @@
<html>
<head>
<title> Criar expressões </title>
</head>
<body bgcolor="FFFFFF">
<h1> Criar expressões </h1>
<p> Para cada variável de saída, a janela Análise Combinacional
manterá duas estruturas - uma coluna correspondente na tabela-verdade,
e uma expressão lógica - que especificará a forma como cada entrada se
relacionará com a sua saída. Você poderá editar tanto a tabela-verdade ou a expressão,
que isso mudará a outra automaticamente, conforme necessário, para mantê-las coerentes.
</p>
<p> Como veremos a seguir, as expressões lógicas (ou booleanas) são
particularmente úteis, pois a janela Análise Combinacional as usará quando
for construir um circuito que corresponda ao estado atual.
</p>
<p> Você poderá visualizar e editar as expressões usando as duas últimas
guias da janela: a Expressão (Expression) e a Minimizada (Minimized).
</p>
<h2> A guia Expressão (Expression) </h2>
<center> <img src="combexpr.png" width="460" height="389">
<h5>(Figura do original em inglês)</h5></center>
<p> A guia Expression permite visualizar e editar as expressões correntes
associadas a cada variável de saída. Você poderá selecionar a expressão de saída
que desejar visualizar e editá-la usando o seletor rotulado como "Saída:"
("Output:") na parte superior do painel.
</p>
<p> Logo abaixo do seletor aparecerá a expressão formatada em uma notação
particularmente comum, onde uma porta OR será representada como adição,
uma porta AND será representada como multiplicação, e porta NOT é denotada
com uma barra acima da parte afetada pela negação.
</p>
<p> O painel de texto embaixo mostra a mesma informação em formato ASCII.
Aqui, uma porta NOT será representada por um til ('~').
</p>
<p> Você poderá editar a expressão no painel de texto e clicar no botão
Entrar (Enter) para torná-la efetiva; isso também irá atualizar a tabela-verdade
para mantê-la coerente. O botão Limpar (Clear) apagará o painel de texto,
e botão Restaurar (Revert) fará o painel voltar a representar a expressão atual.
</p>
<p> Observar que as expressões editadas serão perdidas se você editar a
tabela-verdade.
</p>
<p> Além dos sinais de multiplicação e adição em lugar das portas AND e OR,
uma expressão poderá conter qualquer tipo de operadores lógicos em C/Java,
bem como as próprias palavras (AND, OR, NOT).
</p>
<center><table>
<tr><th>maior precedência:</th><td align="center"><tt>~</tt> <tt>!</tt></td> <th>NOT</th></tr>
<tr><th></th><td align="center">(nada) <tt>&amp;</tt> <tt>&amp;&amp;</tt></td> <th>AND</th></tr>
<tr><th></th><td align="center"><tt>^</tt></td> <th>XOR</th></tr>
<tr><th>menor precedência:</th><td align="center"><tt>+</tt> <tt>|</tt> <tt>||</tt></td> <th>OR</th></tr>
</table></center>
<p> Os exemplos a seguir são representações válidas de uma mesma expressão. Você também
poderá misturar os operadores.
</p>
<table>
<tr><td><tt>~a (b + c)</tt></td></tr>
<tr><td><tt>!a &amp;&amp; (b || c)</tt></td></tr>
<tr><td><tt>NOT a AND (b OR c)</tt></td></tr>
</table>
<p> Em geral, os parênteses sobre uma sequência de ANDs (ou ORs ou XORs) não importam.
(Em particular, se criar um circuito correspondente no Logisim, ele irá ignorá-los.)
</p>
<h2> A guia Minimizada (Minimized)</h2>
<center><img src="combmin.png" width="460" height="389">
<h5>(Figura do original em inglês)</h5></center>
<p> A última guia exibe uma soma de produtos minimizada correspondente
a uma coluna da tabela-verdade. Você poderá selecionar qual a expressão
minimizada de saída deverá ser exibida usando o seletor na parte superior.
</p>
<p> Se houver quatro entradas ou menos, um mapa de Karnaugh correspondente
à variável irá aparecer abaixo do seletor. Você poderá clicar no
mapa de Karnaugh para alterar os valores na tabela-verdade. O mapa de Karnaugh
também apresentará os termos selecionados para a expressão minimizada por meio de
retângulos arredondados, sólidos, semitransparentes.
</p>
<p> Embaixo estará a expressão minimizada, formatada como mostrado na guia
Expressão (Expression). Se houver mais de quatro entradas, o mapa de Karnaugh
não aparecerá, mas a expressão minimizada ainda será calculada.
(O Logisim usa o algoritmo de Quine-McCluskey para calcular a expressão minimizada.
Isso é equivalente a um mapa de Karnaugh, mas se aplica a qualquer número de variáveis
de entrada.)
</p>
<p> O botão Definir Como Expressão (Set As Expression) permitirá selecionar
a expressão minimizada como aquela correspondente à variável. Isso geralmente
não será necessário, já que editar a tabela-verdade resultará no uso da
expressão minimizada para a coluna alterada, mas se você digitar uma expressão
através da guia apropriada, esta também poderá ser uma maneira conveniente
para se alterar a expressão minimizada correspondente.
</p>
<p><strong>Próximo:</strong> <a href="gen.html">Gerar um circuito</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title> Criar expressões </title>
</head>
<body bgcolor="FFFFFF">
<h1> Criar expressões </h1>
<p> Para cada variável de saída, a janela Análise Combinacional
manterá duas estruturas - uma coluna correspondente na tabela-verdade,
e uma expressão lógica - que especificará a forma como cada entrada se
relacionará com a sua saída. Você poderá editar tanto a tabela-verdade ou a expressão,
que isso mudará a outra automaticamente, conforme necessário, para mantê-las coerentes.
</p>
<p> Como veremos a seguir, as expressões lógicas (ou booleanas) são
particularmente úteis, pois a janela Análise Combinacional as usará quando
for construir um circuito que corresponda ao estado atual.
</p>
<p> Você poderá visualizar e editar as expressões usando as duas últimas
guias da janela: a Expressão (Expression) e a Minimizada (Minimized).
</p>
<h2> A guia Expressão (Expression) </h2>
<center> <img src="combexpr.png" width="460" height="389">
<h5>(Figura do original em inglês)</h5></center>
<p> A guia Expression permite visualizar e editar as expressões correntes
associadas a cada variável de saída. Você poderá selecionar a expressão de saída
que desejar visualizar e editá-la usando o seletor rotulado como "Saída:"
("Output:") na parte superior do painel.
</p>
<p> Logo abaixo do seletor aparecerá a expressão formatada em uma notação
particularmente comum, onde uma porta OR será representada como adição,
uma porta AND será representada como multiplicação, e porta NOT é denotada
com uma barra acima da parte afetada pela negação.
</p>
<p> O painel de texto embaixo mostra a mesma informação em formato ASCII.
Aqui, uma porta NOT será representada por um til ('~').
</p>
<p> Você poderá editar a expressão no painel de texto e clicar no botão
Entrar (Enter) para torná-la efetiva; isso também irá atualizar a tabela-verdade
para mantê-la coerente. O botão Limpar (Clear) apagará o painel de texto,
e botão Restaurar (Revert) fará o painel voltar a representar a expressão atual.
</p>
<p> Observar que as expressões editadas serão perdidas se você editar a
tabela-verdade.
</p>
<p> Além dos sinais de multiplicação e adição em lugar das portas AND e OR,
uma expressão poderá conter qualquer tipo de operadores lógicos em C/Java,
bem como as próprias palavras (AND, OR, NOT).
</p>
<center><table>
<tr><th>maior precedência:</th><td align="center"><tt>~</tt> <tt>!</tt></td> <th>NOT</th></tr>
<tr><th></th><td align="center">(nada) <tt>&amp;</tt> <tt>&amp;&amp;</tt></td> <th>AND</th></tr>
<tr><th></th><td align="center"><tt>^</tt></td> <th>XOR</th></tr>
<tr><th>menor precedência:</th><td align="center"><tt>+</tt> <tt>|</tt> <tt>||</tt></td> <th>OR</th></tr>
</table></center>
<p> Os exemplos a seguir são representações válidas de uma mesma expressão. Você também
poderá misturar os operadores.
</p>
<table>
<tr><td><tt>~a (b + c)</tt></td></tr>
<tr><td><tt>!a &amp;&amp; (b || c)</tt></td></tr>
<tr><td><tt>NOT a AND (b OR c)</tt></td></tr>
</table>
<p> Em geral, os parênteses sobre uma sequência de ANDs (ou ORs ou XORs) não importam.
(Em particular, se criar um circuito correspondente no Logisim, ele irá ignorá-los.)
</p>
<h2> A guia Minimizada (Minimized)</h2>
<center><img src="combmin.png" width="460" height="389">
<h5>(Figura do original em inglês)</h5></center>
<p> A última guia exibe uma soma de produtos minimizada correspondente
a uma coluna da tabela-verdade. Você poderá selecionar qual a expressão
minimizada de saída deverá ser exibida usando o seletor na parte superior.
</p>
<p> Se houver quatro entradas ou menos, um mapa de Karnaugh correspondente
à variável irá aparecer abaixo do seletor. Você poderá clicar no
mapa de Karnaugh para alterar os valores na tabela-verdade. O mapa de Karnaugh
também apresentará os termos selecionados para a expressão minimizada por meio de
retângulos arredondados, sólidos, semitransparentes.
</p>
<p> Embaixo estará a expressão minimizada, formatada como mostrado na guia
Expressão (Expression). Se houver mais de quatro entradas, o mapa de Karnaugh
não aparecerá, mas a expressão minimizada ainda será calculada.
(O Logisim usa o algoritmo de Quine-McCluskey para calcular a expressão minimizada.
Isso é equivalente a um mapa de Karnaugh, mas se aplica a qualquer número de variáveis
de entrada.)
</p>
<p> O botão Definir Como Expressão (Set As Expression) permitirá selecionar
a expressão minimizada como aquela correspondente à variável. Isso geralmente
não será necessário, já que editar a tabela-verdade resultará no uso da
expressão minimizada para a coluna alterada, mas se você digitar uma expressão
através da guia apropriada, esta também poderá ser uma maneira conveniente
para se alterar a expressão minimizada correspondente.
</p>
<p><strong>Próximo:</strong> <a href="gen.html">Gerar um circuito</a>.</p>
</body>
</html>

86
doc/pt/html/guide/analyze/gen.html
View File

@ -1,43 +1,43 @@
<html>
<head>
<title>Gerar um circuito</title>
</head>
<body bgcolor="FFFFFF">
<h1> Gerar um circuito </h1>
<p> O botão Gerar Circuito (Build Circuit) irá construir um circuito cujas portas
corresponderão às expressões correntes escolhidas para cada saída. As
entradas e saídas do circuito serão exibidas em ordem de cima para baixo
correspondente à forma como elas aparecem sob as guias Entradas (Inputs) e Saídas
(Outputs). De modo geral, o circuito será construído de forma bem clara; na verdade,
uma aplicação do módulo de Análise Combinacional do Logisim é posicionar bem circuitos
mesmo que mal desenhados. Ainda assim, como acontece com qualquer formatação automática,
não irá expressar os detalhes estruturais como um circuito desenhado por um humano faria.
</p>
<p> Quando você clicar no botão Gerar Circuito (Build Circuit), uma caixa de diálogo
irá aparecer solicitando que você escolha em qual projeto desejará colocar o circuito
e que nome quer lhe dar. Se você digitar o nome de um circuito já existente,
então esse circuito será substituído (após o Logisim perguntar se você realmente
quer fazer isso).
</p>
<p> A caixa de diálogo Gerar Circuito (Build Circuit) inclui duas opções. A opção
para Usar Portas Com Apenas Duas Entradas especifica que você deseja que todas
as portas usadas a partir de então tenham duas entradas. (As portas NOT, é claro,
constituem uma exceção a essa regra.) A opção Usar Apenas Portas NAND especifica
que você gostaria que o circuito fosse traduzido usando apenas essas portas.
Você poderá selecionar ambas as opções, se quiser usar apenas portas NAND de duas
entradas.
</p>
<p> O Logisim não poderá construir um circuito somente com portas NAND para uma
expressão contendo operadores XOR. Essa opção, portanto, será desativada
se qualquer das expressões de saídas contiver XOR's.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Gerar um circuito</title>
</head>
<body bgcolor="FFFFFF">
<h1> Gerar um circuito </h1>
<p> O botão Gerar Circuito (Build Circuit) irá construir um circuito cujas portas
corresponderão às expressões correntes escolhidas para cada saída. As
entradas e saídas do circuito serão exibidas em ordem de cima para baixo
correspondente à forma como elas aparecem sob as guias Entradas (Inputs) e Saídas
(Outputs). De modo geral, o circuito será construído de forma bem clara; na verdade,
uma aplicação do módulo de Análise Combinacional do Logisim é posicionar bem circuitos
mesmo que mal desenhados. Ainda assim, como acontece com qualquer formatação automática,
não irá expressar os detalhes estruturais como um circuito desenhado por um humano faria.
</p>
<p> Quando você clicar no botão Gerar Circuito (Build Circuit), uma caixa de diálogo
irá aparecer solicitando que você escolha em qual projeto desejará colocar o circuito
e que nome quer lhe dar. Se você digitar o nome de um circuito já existente,
então esse circuito será substituído (após o Logisim perguntar se você realmente
quer fazer isso).
</p>
<p> A caixa de diálogo Gerar Circuito (Build Circuit) inclui duas opções. A opção
para Usar Portas Com Apenas Duas Entradas especifica que você deseja que todas
as portas usadas a partir de então tenham duas entradas. (As portas NOT, é claro,
constituem uma exceção a essa regra.) A opção Usar Apenas Portas NAND especifica
que você gostaria que o circuito fosse traduzido usando apenas essas portas.
Você poderá selecionar ambas as opções, se quiser usar apenas portas NAND de duas
entradas.
</p>
<p> O Logisim não poderá construir um circuito somente com portas NAND para uma
expressão contendo operadores XOR. Essa opção, portanto, será desativada
se qualquer das expressões de saídas contiver XOR's.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>

86
doc/pt/html/guide/analyze/index.html
View File

@ -1,43 +1,43 @@
<html>
<head>
<title>Análise Combinacional</title>
</head>
<body bgcolor="FFFFFF">
<h1>Análise combinacional</h1>
<center><img src="combmin.png" width="460" height="389">
<h5>(Figura do original em inglês)</h5></center>
<p> Todos os circuitos podem ser separados em duas categorias bem conhecidas:
a dos circuitos <strong>combinacionais</strong>, onde todas as saídas são
<em>combinações</em> estritas das entradas correntes; ou a dos <strong>circuitos
sequenciais</strong>, onde algumas saídas podem depender de entradas anteriores
(a <em>sequência</em> de entradas ao longo do tempo).
</p>
<p> A categoria de circuitos combinacionais é a mais simples das duas. Seus usuários
costumam usar três técnicas principais para resumir o comportamento de tais circuitos:
<ul>
<li> circuitos lógicos,
<li> expressões lógicas (booleanas), que permitem uma representação algébrica
de como o circuito funciona,
<li> tabelas-verdade, que listam todas as combinações possíveis das entradas e
das saídas correspondentes.
</ul>
O módulo <em> Análise Combinacional </em> do Logisim permite converter entre essas
três representações, em qualquer sentido. É uma maneira particularmente útil para
se criar e entender circuitos a partir de algumas entradas e saídas de um bit cada.
</p>
<blockquote><a href="open.html"> Abrir Análise Combinacional </a>
<br> <a href="table.html"> Editar a tabela-verdade </a>
<br> <a href="expr.html"> Criar expressões </a>
<br> <a href="gen.html"> Gerar um circuito </a>
</blockquote>
<p><strong>Próximo:</strong> <a href="open.html">Abrir Análise Combinacional</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Análise Combinacional</title>
</head>
<body bgcolor="FFFFFF">
<h1>Análise combinacional</h1>
<center><img src="combmin.png" width="460" height="389">
<h5>(Figura do original em inglês)</h5></center>
<p> Todos os circuitos podem ser separados em duas categorias bem conhecidas:
a dos circuitos <strong>combinacionais</strong>, onde todas as saídas são
<em>combinações</em> estritas das entradas correntes; ou a dos <strong>circuitos
sequenciais</strong>, onde algumas saídas podem depender de entradas anteriores
(a <em>sequência</em> de entradas ao longo do tempo).
</p>
<p> A categoria de circuitos combinacionais é a mais simples das duas. Seus usuários
costumam usar três técnicas principais para resumir o comportamento de tais circuitos:
<ul>
<li> circuitos lógicos,
<li> expressões lógicas (booleanas), que permitem uma representação algébrica
de como o circuito funciona,
<li> tabelas-verdade, que listam todas as combinações possíveis das entradas e
das saídas correspondentes.
</ul>
O módulo <em> Análise Combinacional </em> do Logisim permite converter entre essas
três representações, em qualquer sentido. É uma maneira particularmente útil para
se criar e entender circuitos a partir de algumas entradas e saídas de um bit cada.
</p>
<blockquote><a href="open.html"> Abrir Análise Combinacional </a>
<br> <a href="table.html"> Editar a tabela-verdade </a>
<br> <a href="expr.html"> Criar expressões </a>
<br> <a href="gen.html"> Gerar um circuito </a>
</blockquote>
<p><strong>Próximo:</strong> <a href="open.html">Abrir Análise Combinacional</a>.</p>
</body>
</html>

182
doc/pt/html/guide/analyze/open.html
View File

@ -1,91 +1,91 @@
<html>
<head>
<title>Abrir Análise Combinacional</title>
</head>
<body bgcolor="FFFFFF">
<h1>Abrir Análise Combinacional</h1>
<p> A maior parte do módulo Análise Combinacional é acessível através de
uma janela de mesmo nome, que lhe permitirá ver tabelas-verdade e
expressões lógicas (booleanas). Essa janela poderá ser aberta de duas maneiras.
</p>
<h2> Através do menu Janela </h2>
<p> Ao selecionar Análise Combinacional, a atual será exibida na janela.
Se você não tiver usado a janela antes, ela estará vazia e não estará
analisando qualquer circuito.
</p>
<p> Apenas uma janela Análise Combinacional existirá dentro do Logisim,
não importa quantos projetos estiverem abertos. Não há como permitir que
se tenham duas análises diferentes abertas ao mesmo tempo.
</p>
<h2> Através do menu Projeto </h2>
<p> A partir de uma janela para edição de circuitos, você também poderá solicitar
que o Logisim analise o circuito corrente, se selecionar a opção Analisar Circuito
no menu Projeto. Antes de abrir a janela, o Logisim irá calcular as expressões
lógicas (booleanas) e montará uma tabela-verdade correspondente ao circuito.
</p>
<p> Para que a análise seja bem sucedida, cada entrada ou saída deverá ser conectada
a cada um de seus respectivos pinos de entrada ou saída.
O Logisim só analisará circuitos com no máximo oito de cada tipo, e todos deverão
ser pinos com largura de um bit apenas. Caso contrário, você irá ver uma mensagem
de erro e a janela não será aberta.
</p>
<p> Ao construir as expressões lógicas (booleanas) correspondentes a um circuito,
o Logisim irá tentar, primeiro, construir expressões que correspondam exatamente às
portas do circuito. Mas, se o circuito utilizar componentes que não sejam portas
(como um multiplexador), ou se o circuito tiver mais de 100 níveis de profundidade
(pouco provável), então aparecerá uma caixa de diálogo informando que foi impossível
montar a expressão; e alternativamente, o Logisim tentará derivar as expressões
baseando-se na tabela-verdade, que será determinada para cada combinação de
entradas e pelas leituras das saídas resultantes.
</p>
<p> Depois de analisar um circuito, não haverá uma relação de continuidade entre
o circuito e a janela de Análise Combinacional. Ou seja, mudanças no circuito não
serão refletidas na janela, nem mudanças nas expressões lógicas (booleanas) e/ou
na tabela-verdade serão refletidas no circuito. Você sempre terá liberdade para
analisar o circuito novamente e, como veremos mais adiante, ou poderá substituir
aquele que estiver na janela da Análise Combinacional.
</p>
<h2>Limitações</h2>
<p> O Logisim não tentará detectar circuitos sequenciais: se você disser para
analisar um circuito sequencial, ele tentará criar uma tabela-verdade
e as correspondentes expressões lógicas (booleanas), ainda que essas
possam não indicar precisamente o comportamento do circuito. (Na verdade,
detectar circuitos sequenciais é <em>comprovadamente impossível</em>, de mesma
monta como seria resolver o Problema da Parada. Claro, você poderia esperar que
o Logisim fizesse, pelo menos, algumas tentativas - talvez procurar
flip-flops ou ciclos nas conexões, mas ele não fará). Como resultado,
o sistema de Análise Combinacional não deverá ser usado indiscriminadamente:
use-o somente quando você tiver certeza de que o circuito que quiser analisar
for realmente combinacional!
</p>
<p> O Logisim fará uma mudança no circuito original, que é talvez seja
inesperada: o sistema de Análise Combinacional exige que cada
entrada e saída possua um nome exclusivo em conformidade com as regras de
identificadores Java. (De forma resumida, cada identificador deverá ter letras
ou algarismos, e começar por letra. Espaços em branco não serão permitidos!)
Ele tentará usar os rótulos dos pinos existentes, antes de usar uma lista de
nomes padronizados, caso não haja rótulo. Se as regras não forem seguidas,
o Logisim tentará extrair um válido a partir dos nomes nos rótulos, se possível.
</p>
<p> Aliás, a ordem das entradas na tabela-verdade combinará com seus pares
em ordem decrescente no circuito original, seguindo da esquerda para a direita.
(O mesmo vale para ordenar as saídas.) </ p>
<p><strong>Próximo:</strong> <a href="table.html">Editar a tabela-verdade</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Abrir Análise Combinacional</title>
</head>
<body bgcolor="FFFFFF">
<h1>Abrir Análise Combinacional</h1>
<p> A maior parte do módulo Análise Combinacional é acessível através de
uma janela de mesmo nome, que lhe permitirá ver tabelas-verdade e
expressões lógicas (booleanas). Essa janela poderá ser aberta de duas maneiras.
</p>
<h2> Através do menu Janela </h2>
<p> Ao selecionar Análise Combinacional, a atual será exibida na janela.
Se você não tiver usado a janela antes, ela estará vazia e não estará
analisando qualquer circuito.
</p>
<p> Apenas uma janela Análise Combinacional existirá dentro do Logisim,
não importa quantos projetos estiverem abertos. Não há como permitir que
se tenham duas análises diferentes abertas ao mesmo tempo.
</p>
<h2> Através do menu Projeto </h2>
<p> A partir de uma janela para edição de circuitos, você também poderá solicitar
que o Logisim analise o circuito corrente, se selecionar a opção Analisar Circuito
no menu Projeto. Antes de abrir a janela, o Logisim irá calcular as expressões
lógicas (booleanas) e montará uma tabela-verdade correspondente ao circuito.
</p>
<p> Para que a análise seja bem sucedida, cada entrada ou saída deverá ser conectada
a cada um de seus respectivos pinos de entrada ou saída.
O Logisim só analisará circuitos com no máximo oito de cada tipo, e todos deverão
ser pinos com largura de um bit apenas. Caso contrário, você irá ver uma mensagem
de erro e a janela não será aberta.
</p>
<p> Ao construir as expressões lógicas (booleanas) correspondentes a um circuito,
o Logisim irá tentar, primeiro, construir expressões que correspondam exatamente às
portas do circuito. Mas, se o circuito utilizar componentes que não sejam portas
(como um multiplexador), ou se o circuito tiver mais de 100 níveis de profundidade
(pouco provável), então aparecerá uma caixa de diálogo informando que foi impossível
montar a expressão; e alternativamente, o Logisim tentará derivar as expressões
baseando-se na tabela-verdade, que será determinada para cada combinação de
entradas e pelas leituras das saídas resultantes.
</p>
<p> Depois de analisar um circuito, não haverá uma relação de continuidade entre
o circuito e a janela de Análise Combinacional. Ou seja, mudanças no circuito não
serão refletidas na janela, nem mudanças nas expressões lógicas (booleanas) e/ou
na tabela-verdade serão refletidas no circuito. Você sempre terá liberdade para
analisar o circuito novamente e, como veremos mais adiante, ou poderá substituir
aquele que estiver na janela da Análise Combinacional.
</p>
<h2>Limitações</h2>
<p> O Logisim não tentará detectar circuitos sequenciais: se você disser para
analisar um circuito sequencial, ele tentará criar uma tabela-verdade
e as correspondentes expressões lógicas (booleanas), ainda que essas
possam não indicar precisamente o comportamento do circuito. (Na verdade,
detectar circuitos sequenciais é <em>comprovadamente impossível</em>, de mesma
monta como seria resolver o Problema da Parada. Claro, você poderia esperar que
o Logisim fizesse, pelo menos, algumas tentativas - talvez procurar
flip-flops ou ciclos nas conexões, mas ele não fará). Como resultado,
o sistema de Análise Combinacional não deverá ser usado indiscriminadamente:
use-o somente quando você tiver certeza de que o circuito que quiser analisar
for realmente combinacional!
</p>
<p> O Logisim fará uma mudança no circuito original, que é talvez seja
inesperada: o sistema de Análise Combinacional exige que cada
entrada e saída possua um nome exclusivo em conformidade com as regras de
identificadores Java. (De forma resumida, cada identificador deverá ter letras
ou algarismos, e começar por letra. Espaços em branco não serão permitidos!)
Ele tentará usar os rótulos dos pinos existentes, antes de usar uma lista de
nomes padronizados, caso não haja rótulo. Se as regras não forem seguidas,
o Logisim tentará extrair um válido a partir dos nomes nos rótulos, se possível.
</p>
<p> Aliás, a ordem das entradas na tabela-verdade combinará com seus pares
em ordem decrescente no circuito original, seguindo da esquerda para a direita.
(O mesmo vale para ordenar as saídas.) </ p>
<p><strong>Próximo:</strong> <a href="table.html">Editar a tabela-verdade</a>.</p>
</body>
</html>

150
doc/pt/html/guide/analyze/table.html
View File

@ -1,75 +1,75 @@
<html>
<head>
<title>Editar a tabela-verdade</title>
</head>
<body bgcolor="FFFFFF">
<h1>Editar a tabela-verdade</h1>
<p> Ao abrir a janela da Análise Combinacional, você irá ver que é
composto de cinco guias.</p>
<center> <img src="combvar.png" width="460" height="389">
<h5>(Figura do original em inglês)</h5></center>
<p> Esta página descreve as três primeiras guias: Entradas (Inputs), Saídas (Outputs)
e Tabela (Table). A próxima página do manual descreverá as duas últimas guias:
Expressão (Expression) e Minimizada (Minimized).
</p>
<h2> As guias Entradas e Saídas </h2>
<p> A guia Entradas permitirá visualizar e editar a lista de entradas.
Para adicionar novas entradas, digite-as no campo apropriado na parte inferior
do painel, e clique em Adicionar. Se você quiser mudar o nome de uma entrada existente,
selecione-a na lista que aparecer na parte superior do painel à esquerda, em seguida,
digite o nome e clique em Renomear.
</p>
<p> Para remover uma entrada, selecione-a na lista e clique em Remover.
Você também poderá reordenar as entradas (isso afetará a ordem das
colunas na tabela-verdade e no circuito gerado), utilizando os botões para
mover para cima (Move Up) ou para baixo (Move Down) sobre uma entrada
selecionada.
</p>
<p> Todas as ações afetarão a tabela verdade imediatamente.
</p>
<p> A guia Saídas funciona exatamente da mesma maneira como a guia Entradas,
exceto, claro, que funcionará com a lista de saídas.
</p>
<h2> A guia Tabela </h2>
<p> O único item nessa guia é a tabela-verdade corrente,
diagramado na ordem convencional, com as entradas nas colunas à esquerda e
as saídas nas colunas à direita.
</p>
<p> Você poderá editar os valores atuais nas colunas de saída
clicando sobre eles. Os valores irão variar de 0, 1, e <em>x</em>
(que representará um "don't care"). Como veremos na próxima página, esses valores
"don't care" permitirão calcular expressões minimizadas com alguma flexibilidade.
</p>
<p> Você também poderá navegar e editar a tabela-verdade usando o teclado.
E poderá copiar e colar valores usando a área de transferência.
A área de transferência poderá ser transferida para qualquer aplicação que suporte
texto delimitado por tabulação (como em uma planilha).
</p>
<p> Se a tabela-verdade for baseada em um circuito existente, você poderá ver
alguns quadrados róseos nas colunas das saídas marcados com "!!". Eles corresponderão
a erros que ocorrerem enquanto for feito o cálculo do valor para aquela linha -
ou quando o circuito estiver oscilando, ou ainda quando resultar em erro
(o que será retratado como uma conexão vermelha no circuito Logisim).
Ao passar o mouse sobre a entrada isso deverá trazer uma dica descrevendo
o tipo de erro gerado. Uma vez que você tenha clicado sobre uma entrada de erro,
você entrará no ciclo 0-1-<em>x</em>; não haverá como voltar.
</p>
<p><strong>Próximo:</strong> <a href="expr.html">Criar expressões</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Editar a tabela-verdade</title>
</head>
<body bgcolor="FFFFFF">
<h1>Editar a tabela-verdade</h1>
<p> Ao abrir a janela da Análise Combinacional, você irá ver que é
composto de cinco guias.</p>
<center> <img src="combvar.png" width="460" height="389">
<h5>(Figura do original em inglês)</h5></center>
<p> Esta página descreve as três primeiras guias: Entradas (Inputs), Saídas (Outputs)
e Tabela (Table). A próxima página do manual descreverá as duas últimas guias:
Expressão (Expression) e Minimizada (Minimized).
</p>
<h2> As guias Entradas e Saídas </h2>
<p> A guia Entradas permitirá visualizar e editar a lista de entradas.
Para adicionar novas entradas, digite-as no campo apropriado na parte inferior
do painel, e clique em Adicionar. Se você quiser mudar o nome de uma entrada existente,
selecione-a na lista que aparecer na parte superior do painel à esquerda, em seguida,
digite o nome e clique em Renomear.
</p>
<p> Para remover uma entrada, selecione-a na lista e clique em Remover.
Você também poderá reordenar as entradas (isso afetará a ordem das
colunas na tabela-verdade e no circuito gerado), utilizando os botões para
mover para cima (Move Up) ou para baixo (Move Down) sobre uma entrada
selecionada.
</p>
<p> Todas as ações afetarão a tabela verdade imediatamente.
</p>
<p> A guia Saídas funciona exatamente da mesma maneira como a guia Entradas,
exceto, claro, que funcionará com a lista de saídas.
</p>
<h2> A guia Tabela </h2>
<p> O único item nessa guia é a tabela-verdade corrente,
diagramado na ordem convencional, com as entradas nas colunas à esquerda e
as saídas nas colunas à direita.
</p>
<p> Você poderá editar os valores atuais nas colunas de saída
clicando sobre eles. Os valores irão variar de 0, 1, e <em>x</em>
(que representará um "don't care"). Como veremos na próxima página, esses valores
"don't care" permitirão calcular expressões minimizadas com alguma flexibilidade.
</p>
<p> Você também poderá navegar e editar a tabela-verdade usando o teclado.
E poderá copiar e colar valores usando a área de transferência.
A área de transferência poderá ser transferida para qualquer aplicação que suporte
texto delimitado por tabulação (como em uma planilha).
</p>
<p> Se a tabela-verdade for baseada em um circuito existente, você poderá ver
alguns quadrados róseos nas colunas das saídas marcados com "!!". Eles corresponderão
a erros que ocorrerem enquanto for feito o cálculo do valor para aquela linha -
ou quando o circuito estiver oscilando, ou ainda quando resultar em erro
(o que será retratado como uma conexão vermelha no circuito Logisim).
Ao passar o mouse sobre a entrada isso deverá trazer uma dica descrevendo
o tipo de erro gerado. Uma vez que você tenha clicado sobre uma entrada de erro,
você entrará no ciclo 0-1-<em>x</em>; não haverá como voltar.
</p>
<p><strong>Próximo:</strong> <a href="expr.html">Criar expressões</a>.</p>
</body>
</html>

118
doc/pt/html/guide/attrlib/attr.html
View File

@ -1,59 +1,59 @@
<html>
<head>
<title>A tabela de atributos</title>
</head>
<body bgcolor="FFFFFF">
<h1>A tabela de atributos</h1>
<p> Muitos componentes têm <strong>atributos</strong>, que são
propriedades para configurar como ele se comportará ou aparecerá.
A <strong> tabela de atributos </strong> serve para exibir valores
dos atributos do componentes.
</p>
<p> Para selecionar quais atributos do componente deseja visualizar,
clique no componente usando a ferramenta Editar
(<img Src="../../icons/select.gif" width="16" height="16">).
(Você também poderá clicar com o botão direito (ou control-click) no componente
e escolher Mostrar Atributos (Show Attributes) no menu pop-up. Além disso,
poderá manipular um componente através da ferramenta Testar (Poke)
(<img Src="../../icons/poke.gif" width="16" height="16">) ou da ferramenta Texto
(<img Src="../../icons/text.gif" width="16" height="16">) que irá mostrar os
atributos do componente.)
</p>
<p> A tela abaixo demonstra o que as coisas irá aparecer depois que
selecionar a entrada superior do circuito XOR e rolar para baixo até ver o atributo
Fonte do Rótulo (Label Font).
</p>
<center> <img src="pin-attrib.png" width="459" height="271">
<h5>(Figura do original em inglês)</h5></center>
<p> Para modificar um valor de atributo, clique sobre o valor. A interface
para modificar o atributo vai depender de qual atributo quiser mudar,
no caso de ser a Fonte do Rótulo do atributo, uma caixa de diálogo aparecerá
para selecionar a nova fonte; mas alguns atributos (como Rótulo/Label) permitirão
que você edite o valor em um campo de texto, enquanto outros (como a
Direção do Rótulo) serão exibidos em um menu drop-down a partir do qual
poderá escolher o valor.
</p>
<p> Cada tipo de componente tem um conjunto diferente de atributos.
Para saber o que significam, vá para a documentação pertinente em
<a href="../../libs/index.html">Referências para Bibliotecas</a>.
</p>
<p> Se você selecionar vários componentes usando a ferramenta Editar, em seguida,
a tabela exibirá aqueles atributos compartilhados por todos os selecionados
(excluindo quaisquer conexões). Se os componentes selecionados não tiverem todos
o mesmo valor para o atributo, então o valor exibido ficará em branco.
Você poderá alterar os valores de todos os atributos dos componentes selecionados
de uma vez também usando a tabela.
</p>
<p><strong>Próximo:</strong> <a href="tool.html">Atributos de ferramenta</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A tabela de atributos</title>
</head>
<body bgcolor="FFFFFF">
<h1>A tabela de atributos</h1>
<p> Muitos componentes têm <strong>atributos</strong>, que são
propriedades para configurar como ele se comportará ou aparecerá.
A <strong> tabela de atributos </strong> serve para exibir valores
dos atributos do componentes.
</p>
<p> Para selecionar quais atributos do componente deseja visualizar,
clique no componente usando a ferramenta Editar
(<img Src="../../icons/select.gif" width="16" height="16">).
(Você também poderá clicar com o botão direito (ou control-click) no componente
e escolher Mostrar Atributos (Show Attributes) no menu pop-up. Além disso,
poderá manipular um componente através da ferramenta Testar (Poke)
(<img Src="../../icons/poke.gif" width="16" height="16">) ou da ferramenta Texto
(<img Src="../../icons/text.gif" width="16" height="16">) que irá mostrar os
atributos do componente.)
</p>
<p> A tela abaixo demonstra o que as coisas irá aparecer depois que
selecionar a entrada superior do circuito XOR e rolar para baixo até ver o atributo
Fonte do Rótulo (Label Font).
</p>
<center> <img src="pin-attrib.png" width="459" height="271">
<h5>(Figura do original em inglês)</h5></center>
<p> Para modificar um valor de atributo, clique sobre o valor. A interface
para modificar o atributo vai depender de qual atributo quiser mudar,
no caso de ser a Fonte do Rótulo do atributo, uma caixa de diálogo aparecerá
para selecionar a nova fonte; mas alguns atributos (como Rótulo/Label) permitirão
que você edite o valor em um campo de texto, enquanto outros (como a
Direção do Rótulo) serão exibidos em um menu drop-down a partir do qual
poderá escolher o valor.
</p>
<p> Cada tipo de componente tem um conjunto diferente de atributos.
Para saber o que significam, vá para a documentação pertinente em
<a href="../../libs/index.html">Referências para Bibliotecas</a>.
</p>
<p> Se você selecionar vários componentes usando a ferramenta Editar, em seguida,
a tabela exibirá aqueles atributos compartilhados por todos os selecionados
(excluindo quaisquer conexões). Se os componentes selecionados não tiverem todos
o mesmo valor para o atributo, então o valor exibido ficará em branco.
Você poderá alterar os valores de todos os atributos dos componentes selecionados
de uma vez também usando a tabela.
</p>
<p><strong>Próximo:</strong> <a href="tool.html">Atributos de ferramenta</a>.</p>
</body>
</html>

204
doc/pt/html/guide/attrlib/explore.html
View File

@ -1,102 +1,102 @@
<html>
<head>
<title>O painel Explorador (Explorer)</title>
</head>
<body bgcolor="FFFFFF">
<h1>O painel Explorador (Explorer)</h1>
<p> O Logisim organiza ferramentas em <strong>bibliotecas</strong>. Elas são
exibidas como pastas no painel Explorador. Para acessar os componentes de uma
biblioteca, você só terá que dar um duplo clique na pasta correspondente. Abaixo,
a biblioteca Portas (Gates) foi aberta e selecionada a ferramenta NAND. Você
poderá ver que o Logisim agora estará pronto para adicionar portas NAND ao
circuito.
</p>
<center> <img src="nand-select.png" width="459" height="271">
<h5>(Figura do original em inglês)</h5></center>
<p> Se você consultar as opções na biblioteca Gates, você notará que
não há necessidade em desenvolver um circuito XOR: ele já existe no Logisim.
</p>
<p> Quando você criar um projeto, ele automaticamente incluirá várias bibliotecas:
</p>
<ul>
<li> Base: As ferramentas que são essenciais para se usar o Logisim. </li>
<li> Portas (Gates): Componentes que executam funções lógicas simples. </li>
<li> Plexers: Combinações mais complexas de componentes, como
multiplexadores e decodificadores. </li>
<li> Aritmética: componentes que executam operações aritméticas. </li>
<li> Memória: Componentes que guardam dados, como flip-flops, registradores e
RAM. </li>
<li> Entrada/Saída: Componentes que têm a finalidade de interagir com o usuário. </li>
</ul>
<p> O Logisim permite adicionar mais bibliotecas, usando o submenu
Carregar Biblioteca (Load Library) do menu Projeto. Você poderá ver que o
Logisim tem três categorias de bibliotecas:
</p>
<ul>
<li> <strong> Bibliotecas predefinidas </strong> são aquelas distribuídas
com Logisim. Elas estão documentadas em
<em> <a href="../../libs/index.html"> Referências para Bibliotecas. </a> </em>
</p>
<li> <strong> Bibliotecas do Logisim </strong> são projetos construídos
dentro Logisim e salvos em disco. Você poderá desenvolver um
conjunto de circuitos como um único projeto (como descrito em
<a href="../subcirc/index.html"> subcircuitos </a> deste guia)
e usá-lo como uma biblioteca para outros projetos.
</p>
<li> <strong> Bibliotecas JAR </strong> são bibliotecas desenvolvidas
em Java, mas não distribuídas com o Logisim. Você poderá baixar as
bibliotecas JAR feitas por outros, ou poderá até mesmo escrever a sua
própria como descrito na seção <a href="../jar/index.html"> Bibliotecas JAR </a>
deste guia. Desenvolver uma biblioteca JAR é muito mais difícil do que
desenvolvimento de uma biblioteca Logisim, mas os componentes poderão ser
muito interessantes, incluir coisas como atributos e interação com o usuário.
As bibliotecas predefinidas (exceto Base) foram escritas usando a mesma
API que as bibliotecas JAR podem usar, e demonstram apropriadamente
a gama de funcionalidades que as bibliotecas JAR poderão oferecer.
</p>
<p> Algumas bibliotecas JAR são distribuídas sem qualquer informação sobre
qual a classe Java deverão iniciar. Ao carregar tal tipo, o Logisim
solicitará que você digite um nome da classe. Esse nome de classe deverá
ser previsto por quem distribuir o arquivo JAR.
</p>
</ul>
<p> Para remover uma biblioteca, escolha Descarregar Biblioteca ... no menu
Projeto. O Logisim irá impedi-lo de descarregar bibliotecas que contenham
componentes utilizados em um circuito, que apareçam na barra de ferramentas,
ou que estejam mapeados para um botão do mouse.
</p>
<p> Aliás, uma biblioteca tecnicamente contém ferramentas, não componentes.
Assim, na biblioteca Base poderão ser encontrados a ferramenta Testar (Poke)
(<img Src="../../icons/poke.gif" width="16" height="16">), a ferramenta Editar
(<img Src="../../icons/select.gif" width="16" height="16">), e outras ferramentas
que não correspondam diretamente a componentes individuais. A maioria das
bibliotecas, no entanto, contém apenas ferramentas para adicionar componentes
individuais, todas as outras bibliotecas são assim, exceto a Base.
</p>
<p><strong>Próximo:</strong> <a href="attr.html">A tabela de atributos</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>O painel Explorador (Explorer)</title>
</head>
<body bgcolor="FFFFFF">
<h1>O painel Explorador (Explorer)</h1>
<p> O Logisim organiza ferramentas em <strong>bibliotecas</strong>. Elas são
exibidas como pastas no painel Explorador. Para acessar os componentes de uma
biblioteca, você só terá que dar um duplo clique na pasta correspondente. Abaixo,
a biblioteca Portas (Gates) foi aberta e selecionada a ferramenta NAND. Você
poderá ver que o Logisim agora estará pronto para adicionar portas NAND ao
circuito.
</p>
<center> <img src="nand-select.png" width="459" height="271">
<h5>(Figura do original em inglês)</h5></center>
<p> Se você consultar as opções na biblioteca Gates, você notará que
não há necessidade em desenvolver um circuito XOR: ele já existe no Logisim.
</p>
<p> Quando você criar um projeto, ele automaticamente incluirá várias bibliotecas:
</p>
<ul>
<li> Base: As ferramentas que são essenciais para se usar o Logisim. </li>
<li> Portas (Gates): Componentes que executam funções lógicas simples. </li>
<li> Plexers: Combinações mais complexas de componentes, como
multiplexadores e decodificadores. </li>
<li> Aritmética: componentes que executam operações aritméticas. </li>
<li> Memória: Componentes que guardam dados, como flip-flops, registradores e
RAM. </li>
<li> Entrada/Saída: Componentes que têm a finalidade de interagir com o usuário. </li>
</ul>
<p> O Logisim permite adicionar mais bibliotecas, usando o submenu
Carregar Biblioteca (Load Library) do menu Projeto. Você poderá ver que o
Logisim tem três categorias de bibliotecas:
</p>
<ul>
<li> <strong> Bibliotecas predefinidas </strong> são aquelas distribuídas
com Logisim. Elas estão documentadas em
<em> <a href="../../libs/index.html"> Referências para Bibliotecas. </a> </em>
</p>
<li> <strong> Bibliotecas do Logisim </strong> são projetos construídos
dentro Logisim e salvos em disco. Você poderá desenvolver um
conjunto de circuitos como um único projeto (como descrito em
<a href="../subcirc/index.html"> subcircuitos </a> deste guia)
e usá-lo como uma biblioteca para outros projetos.
</p>
<li> <strong> Bibliotecas JAR </strong> são bibliotecas desenvolvidas
em Java, mas não distribuídas com o Logisim. Você poderá baixar as
bibliotecas JAR feitas por outros, ou poderá até mesmo escrever a sua
própria como descrito na seção <a href="../jar/index.html"> Bibliotecas JAR </a>
deste guia. Desenvolver uma biblioteca JAR é muito mais difícil do que
desenvolvimento de uma biblioteca Logisim, mas os componentes poderão ser
muito interessantes, incluir coisas como atributos e interação com o usuário.
As bibliotecas predefinidas (exceto Base) foram escritas usando a mesma
API que as bibliotecas JAR podem usar, e demonstram apropriadamente
a gama de funcionalidades que as bibliotecas JAR poderão oferecer.
</p>
<p> Algumas bibliotecas JAR são distribuídas sem qualquer informação sobre
qual a classe Java deverão iniciar. Ao carregar tal tipo, o Logisim
solicitará que você digite um nome da classe. Esse nome de classe deverá
ser previsto por quem distribuir o arquivo JAR.
</p>
</ul>
<p> Para remover uma biblioteca, escolha Descarregar Biblioteca ... no menu
Projeto. O Logisim irá impedi-lo de descarregar bibliotecas que contenham
componentes utilizados em um circuito, que apareçam na barra de ferramentas,
ou que estejam mapeados para um botão do mouse.
</p>
<p> Aliás, uma biblioteca tecnicamente contém ferramentas, não componentes.
Assim, na biblioteca Base poderão ser encontrados a ferramenta Testar (Poke)
(<img Src="../../icons/poke.gif" width="16" height="16">), a ferramenta Editar
(<img Src="../../icons/select.gif" width="16" height="16">), e outras ferramentas
que não correspondam diretamente a componentes individuais. A maioria das
bibliotecas, no entanto, contém apenas ferramentas para adicionar componentes
individuais, todas as outras bibliotecas são assim, exceto a Base.
</p>
<p><strong>Próximo:</strong> <a href="attr.html">A tabela de atributos</a>.</p>
</body>
</html>

46
doc/pt/html/guide/attrlib/index.html
View File

@ -1,23 +1,23 @@
<html>
<head>
<title>Bibliotecas e atributos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Bibliotecas e atributos</h1>
<p> Nesta seção, examinaremos como usar duas outras grandes regiões da janela
do Logisim, o <em>Painel do Explorador</em> e a <em>Tabela de Atributos</em>.</p>
<center><img src="../tutorial/shot-labeled.png" width="473" height="247"></center>
<blockquote>
<a href="explore.html">O Painel Explorador</a>
<br><a href="attr.html">A Tabela de Atributos</a>
<br><a href="tool.html">Atributos de ferramentas e componentes</a>
</blockquote>
<p><strong>Próximo:</strong> <a href="explore.html">O Painel do Explorador</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Bibliotecas e atributos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Bibliotecas e atributos</h1>
<p> Nesta seção, examinaremos como usar duas outras grandes regiões da janela
do Logisim, o <em>Painel do Explorador</em> e a <em>Tabela de Atributos</em>.</p>
<center><img src="../tutorial/shot-labeled.png" width="473" height="247"></center>
<blockquote>
<a href="explore.html">O Painel Explorador</a>
<br><a href="attr.html">A Tabela de Atributos</a>
<br><a href="tool.html">Atributos de ferramentas e componentes</a>
</blockquote>
<p><strong>Próximo:</strong> <a href="explore.html">O Painel do Explorador</a>.</p>
</body>
</html>

124
doc/pt/html/guide/attrlib/tool.html
View File

@ -1,62 +1,62 @@
<html>
<head>
<title>Atributos de Ferramenta</title>
</head>
<body bgcolor="FFFFFF">
<h1>Atributos de Ferramenta</h1>
<p> Toda ferramenta para a adição de componentes a um circuito também
possui um conjunto de atributos, que serão transmitidos aos componentes criados
pela ferramenta, embora os atributos dos componentes possam ser alterados sem
afetar os atributos da ferramenta. Quando você selecionar uma ferramenta, o Logisim
vai mudar a tabela de atributos para mostrar aqueles próprios dela.
</p>
<p> Por exemplo, suponha que se queira criar portas AND pequenas.
No momento, cada vez que selecionar a ferramenta, uma porta AND grande será criada.
Mas, se editar o atributo de tamanho da porta, logo após selecionar a ferramenta
(antes de colocar a porta AND no circuito), irá mudar os atributos para a ferramenta,
de modo que futuras portas AND acrescentadas pela ferramenta serão pequenas.
</p>
<center> <img src="and-narrow.png" width="459" height="271">
<h5>(Figura do original em inglês)</h5></center>
<p> Agora, as duas ANDs já existentes poderão ser excluídas e duas novas
adicionadas em seu lugar. Desta vez, eles serão pequenas.
(Se você optar por reduzir o número de entradas para 3, a porta AND
não terá extensão vertical no lado esquerdo. Mas você também
terá que religar ao circuito as conexões que cheguem à porta AND daquele lado.)
</p>
<center><img src="and-replace.png" width="459" height="271">
<h5>(Figura do original em inglês)</h5></center>
<p> Para algumas ferramentas, os ícones que as representam refletem alguns dos
valores de seus atributos. Um exemplo disso é a ferramenta Pino, cujo ícone
mostra a mesma informação que o seu atributo de direção (Facing).
</p>
<p> Os itens na barra de ferramentas possuem um conjunto separado de atributos
correspondentes àquelas no painel Explorador. Assim, mesmo que o item na
barra de ferramentas crie portas AND pequenas, o da biblioteca Portas (Gates)
ainda criará portas AND grandes, a menos você altere seus atributos também.
</p>
<p> Na verdade, os pinos de entradas e de saídas padrões na barra de ferramentas
são duas instâncias do mesmo item na biblioteca Base, mas os conjuntos de atributos
são diferentes. O ícone para a ferramenta Pino é traçado como um círculo ou um quadrado,
dependendo do valor do seu atributo "Saída?".
</p>
<p> O Logisim oferece um atalho útil para se alterar o atributo Direção
que controla aquela em que muitos componentes se orientam: bastar apertar a tecla
da seta, enquanto que a ferramenta for selecionada e automaticamente alterará a
direção do componente.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a>.</em></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Atributos de Ferramenta</title>
</head>
<body bgcolor="FFFFFF">
<h1>Atributos de Ferramenta</h1>
<p> Toda ferramenta para a adição de componentes a um circuito também
possui um conjunto de atributos, que serão transmitidos aos componentes criados
pela ferramenta, embora os atributos dos componentes possam ser alterados sem
afetar os atributos da ferramenta. Quando você selecionar uma ferramenta, o Logisim
vai mudar a tabela de atributos para mostrar aqueles próprios dela.
</p>
<p> Por exemplo, suponha que se queira criar portas AND pequenas.
No momento, cada vez que selecionar a ferramenta, uma porta AND grande será criada.
Mas, se editar o atributo de tamanho da porta, logo após selecionar a ferramenta
(antes de colocar a porta AND no circuito), irá mudar os atributos para a ferramenta,
de modo que futuras portas AND acrescentadas pela ferramenta serão pequenas.
</p>
<center> <img src="and-narrow.png" width="459" height="271">
<h5>(Figura do original em inglês)</h5></center>
<p> Agora, as duas ANDs já existentes poderão ser excluídas e duas novas
adicionadas em seu lugar. Desta vez, eles serão pequenas.
(Se você optar por reduzir o número de entradas para 3, a porta AND
não terá extensão vertical no lado esquerdo. Mas você também
terá que religar ao circuito as conexões que cheguem à porta AND daquele lado.)
</p>
<center><img src="and-replace.png" width="459" height="271">
<h5>(Figura do original em inglês)</h5></center>
<p> Para algumas ferramentas, os ícones que as representam refletem alguns dos
valores de seus atributos. Um exemplo disso é a ferramenta Pino, cujo ícone
mostra a mesma informação que o seu atributo de direção (Facing).
</p>
<p> Os itens na barra de ferramentas possuem um conjunto separado de atributos
correspondentes àquelas no painel Explorador. Assim, mesmo que o item na
barra de ferramentas crie portas AND pequenas, o da biblioteca Portas (Gates)
ainda criará portas AND grandes, a menos você altere seus atributos também.
</p>
<p> Na verdade, os pinos de entradas e de saídas padrões na barra de ferramentas
são duas instâncias do mesmo item na biblioteca Base, mas os conjuntos de atributos
são diferentes. O ícone para a ferramenta Pino é traçado como um círculo ou um quadrado,
dependendo do valor do seu atributo "Saída?".
</p>
<p> O Logisim oferece um atalho útil para se alterar o atributo Direção
que controla aquela em que muitos componentes se orientam: bastar apertar a tecla
da seta, enquanto que a ferramenta for selecionada e automaticamente alterará a
direção do componente.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a>.</em></p>
</body>
</html>

120
doc/pt/html/guide/bundles/colors.html
View File

@ -1,60 +1,60 @@
<html>
<head>
<title>Cores das conexões</title>
</head>
<body bgcolor="FFFFFF">
<h1>Cores das conexões</h1>
<p> Estamos agora em condições de resumir a variedade de cores que as
conexões do Logisim poderão assumir. O pequeno circuito que se segue
ilustra todos elas de uma só vez.
</p>
<center> <img src="colors.png" width="131" height="195">
<h5>(Figura do original em inglês)</h5></center>
<ul>
<li> <strong> Cinza: </strong> A largura em bits das conexões é desconhecida. Isso
ocorre porque o fio não está conectado às entradas ou às saídas de qualquer componente.
(Todas as entradas e as saídas têm uma largura de bits definida.)
</p> </li>
<li> <strong> Azul: </strong> O fio serve para transportar um bit,
mas o valor que ele está carregando no momento não é conhecido.
A entrada é mostrada como um pino tri-state, de modo que ele possa emitir
esse sinal como flutuante.
</p> </li>
<li> <strong> Verde escuro: </strong> O fio está carregando um bit igual a 0.
</p> </li>
<li> <strong> Verde brilhante: </strong> O fio está carregando um bit igual a 1.
</p> </li>
<li> <strong> Preto: </strong> O fio é portador de um valor multi-bit.
Alguns ou mesmo todos os bits poderão não estar especificados.
</p> </li>
<li> <strong> Vermelho: </strong> O fio está carregando um valor com erro.
Isso geralmente acontece porque uma porta não pode determinar a saída correta,
talvez porque não tenha entradas. Também poderá surgir porque dois componentes
estão tentando enviar valores diferentes para o fio; isso acontece no exemplo acima,
onde um pino de entrada tenta colocar 0 enquanto outro tenta colocar 1 no mesmo fio,
causando um conflito. Conexões multi-bit ficarão vermelhas quando qualquer um dos bits
transportadas estiver com erro.
</p> </li>
<li> <strong> Laranja: </strong> Os componentes ligados ao fio não concordam com a
mesma largura de bits. Uma conexão laranja é efetivamente "quebrada": não transportará
sinais entre os componentes. Aqui, conectamos um componente de dois bits a outro
de um bit, de modo a serem incompatíveis.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Cores das conexões</title>
</head>
<body bgcolor="FFFFFF">
<h1>Cores das conexões</h1>
<p> Estamos agora em condições de resumir a variedade de cores que as
conexões do Logisim poderão assumir. O pequeno circuito que se segue
ilustra todos elas de uma só vez.
</p>
<center> <img src="colors.png" width="131" height="195">
<h5>(Figura do original em inglês)</h5></center>
<ul>
<li> <strong> Cinza: </strong> A largura em bits das conexões é desconhecida. Isso
ocorre porque o fio não está conectado às entradas ou às saídas de qualquer componente.
(Todas as entradas e as saídas têm uma largura de bits definida.)
</p> </li>
<li> <strong> Azul: </strong> O fio serve para transportar um bit,
mas o valor que ele está carregando no momento não é conhecido.
A entrada é mostrada como um pino tri-state, de modo que ele possa emitir
esse sinal como flutuante.
</p> </li>
<li> <strong> Verde escuro: </strong> O fio está carregando um bit igual a 0.
</p> </li>
<li> <strong> Verde brilhante: </strong> O fio está carregando um bit igual a 1.
</p> </li>
<li> <strong> Preto: </strong> O fio é portador de um valor multi-bit.
Alguns ou mesmo todos os bits poderão não estar especificados.
</p> </li>
<li> <strong> Vermelho: </strong> O fio está carregando um valor com erro.
Isso geralmente acontece porque uma porta não pode determinar a saída correta,
talvez porque não tenha entradas. Também poderá surgir porque dois componentes
estão tentando enviar valores diferentes para o fio; isso acontece no exemplo acima,
onde um pino de entrada tenta colocar 0 enquanto outro tenta colocar 1 no mesmo fio,
causando um conflito. Conexões multi-bit ficarão vermelhas quando qualquer um dos bits
transportadas estiver com erro.
</p> </li>
<li> <strong> Laranja: </strong> Os componentes ligados ao fio não concordam com a
mesma largura de bits. Uma conexão laranja é efetivamente "quebrada": não transportará
sinais entre os componentes. Aqui, conectamos um componente de dois bits a outro
de um bit, de modo a serem incompatíveis.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>

118
doc/pt/html/guide/bundles/creating.html
View File

@ -1,59 +1,59 @@
<html>
<head>
<title>Para criar cabos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Para criar cabos</h1>
<p> Cada entrada e saída em cada componente de um circuito tem uma largura de bits
associada a ela. Na maioria das vezes a largura do bit será 1, e não haverá como
mudar isso, mas muitos dos componentes predefinidos do Logisim incluem atributos
cujas as larguras de bits de suas entradas e saídas poderão ser escolhidas.
</p>
<p> A tela abaixo apresenta um circuito simples onde se encontra uma operação AND
de duas entradas de três bits cada. Observe que os três bits da saída resultam
dessas entradas. Todos os componentes tiveram seus atributos Bits de Dados alterados
para lidar com três bits, na tela, como exemplo, alguns dos atributos da porta AND
também são mostrados, e dentre eles atributo dos bits de dados (Data Bits) igual a 3.
</p>
<center> <img src="create.png" width="351" height="227">
<h5>(Figura do original em inglês)</h5></center>
<p> Todos os componentes no Logisim possuem uma largura definida para cada bit
de entrada e saída. Por outro lado, a largura em bits de uma conexão é indefinida.
Ela se adaptará aos componentes a que estiver ligada.
Se um fio conectar dois componentes que exijam larguras diferentes,
o Logisim irá reclamar que são "larguras incompatíveis" e indicará onde
com indicações em cor laranja.
Abaixo, o atributo de bits de dados (Data Bits) do pino de saída foi alterado para 1,
e por isso o Logisim reclama que não pode conectar um valor de três bits com outro
de um bit apenas.
</p>
<center> <img src="error.png" width="351" height="227">
<h5>(Figura do original em inglês)</h5></center>
<p> Conexões entre elementos incompatíveis (desenhadas em cor laranja) não transportarão
sinais.
</p>
<p> Para conexões de um único bit, é possível ver logo o que o fio transporta
através das cores verde-claro ou verde-escuro do Logisim, dependendo do valor.
Ele não apresentará valores para as conexões multi-bit: elas ficarão simplesmente
em preto. Você poderá, no entanto, examinar a conexão, clicando com a ferramenta
Testar (Poke) (<img src="../../icons/poke.gif" width="16" height="16">).
</p>
<center> <img src="probe.png" width="351" height="227">
<h5>(Figura do original em inglês)</h5></center>
<p> Esse recurso para sondagem é útil para depuração de circuitos usando
cabos. </p>
<p><strong>Próximo:</strong> <a href="splitting.html">Distribuidores (Splitters)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Para criar cabos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Para criar cabos</h1>
<p> Cada entrada e saída em cada componente de um circuito tem uma largura de bits
associada a ela. Na maioria das vezes a largura do bit será 1, e não haverá como
mudar isso, mas muitos dos componentes predefinidos do Logisim incluem atributos
cujas as larguras de bits de suas entradas e saídas poderão ser escolhidas.
</p>
<p> A tela abaixo apresenta um circuito simples onde se encontra uma operação AND
de duas entradas de três bits cada. Observe que os três bits da saída resultam
dessas entradas. Todos os componentes tiveram seus atributos Bits de Dados alterados
para lidar com três bits, na tela, como exemplo, alguns dos atributos da porta AND
também são mostrados, e dentre eles atributo dos bits de dados (Data Bits) igual a 3.
</p>
<center> <img src="create.png" width="351" height="227">
<h5>(Figura do original em inglês)</h5></center>
<p> Todos os componentes no Logisim possuem uma largura definida para cada bit
de entrada e saída. Por outro lado, a largura em bits de uma conexão é indefinida.
Ela se adaptará aos componentes a que estiver ligada.
Se um fio conectar dois componentes que exijam larguras diferentes,
o Logisim irá reclamar que são "larguras incompatíveis" e indicará onde
com indicações em cor laranja.
Abaixo, o atributo de bits de dados (Data Bits) do pino de saída foi alterado para 1,
e por isso o Logisim reclama que não pode conectar um valor de três bits com outro
de um bit apenas.
</p>
<center> <img src="error.png" width="351" height="227">
<h5>(Figura do original em inglês)</h5></center>
<p> Conexões entre elementos incompatíveis (desenhadas em cor laranja) não transportarão
sinais.
</p>
<p> Para conexões de um único bit, é possível ver logo o que o fio transporta
através das cores verde-claro ou verde-escuro do Logisim, dependendo do valor.
Ele não apresentará valores para as conexões multi-bit: elas ficarão simplesmente
em preto. Você poderá, no entanto, examinar a conexão, clicando com a ferramenta
Testar (Poke) (<img src="../../icons/poke.gif" width="16" height="16">).
</p>
<center> <img src="probe.png" width="351" height="227">
<h5>(Figura do original em inglês)</h5></center>
<p> Esse recurso para sondagem é útil para depuração de circuitos usando
cabos. </p>
<p><strong>Próximo:</strong> <a href="splitting.html">Distribuidores (Splitters)</a>.</p>
</body>
</html>

46
doc/pt/html/guide/bundles/index.html
View File

@ -1,23 +1,23 @@
<html>
<head>
<title>Cabos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Cabos</h1>
<p> Em circuitos simples do Logisim, a maioria das conexões têm um único bit;
mas também lhe será permitido criar cabos que enfeixem fios empacotando múltiplos bits.
O número de bits que viajam ao longo de um cabo será especificado pela sua
<strong>largura em bits</strong>.
</p>
<blockquote> <a href="creating.html"> Para criar cabos </a>
<br> <a href="splitting.html"> Distribuidores (Splitters) </a>
<br> <a href="colors.html"> Cores das conexões </a>
</blockquote>
<p><strong>Próximo:</strong> <a href="creating.html">Para criar cabos</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Cabos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Cabos</h1>
<p> Em circuitos simples do Logisim, a maioria das conexões têm um único bit;
mas também lhe será permitido criar cabos que enfeixem fios empacotando múltiplos bits.
O número de bits que viajam ao longo de um cabo será especificado pela sua
<strong>largura em bits</strong>.
</p>
<blockquote> <a href="creating.html"> Para criar cabos </a>
<br> <a href="splitting.html"> Distribuidores (Splitters) </a>
<br> <a href="colors.html"> Cores das conexões </a>
</blockquote>
<p><strong>Próximo:</strong> <a href="creating.html">Para criar cabos</a>.</p>
</body>
</html>

156
doc/pt/html/guide/bundles/splitting.html
View File

@ -1,78 +1,78 @@
<html>
<head>
<title>Distribuidores (Splitters)</title>
</head>
<body bgcolor="FFFFFF">
<h1>Distribuidores (Splitters)</h1>
<p> Quando você trabalhar com valores multi-bit, muitas vezes poderá querer rotear
bits em direções diferentes.
A ferramenta Distribuidor (Splitter) da biblioteca Base
(<img Src="../../icons/splitter.gif" width="16" height="16">)
lhe permitirá fazer isso.
</p>
<p> Por exemplo, suponha que queiramos construir um circuito que calcula bit a bit
a conjunção de dois nibbles (meio byte) de uma entrada de oito bits
(os quatro bits superiores e os quatro bits inferiores). Teremos um valor de oito bits
no pinos de entrada, e é desejável dividi-lo em dois valores de quatro bits. No
circuito abaixo, usaremos um distribuidor para conseguir isso: a entrada de 8 bits
irá conectar-se ao distribuidor (que se assemelha a um pé de pássaro), que dividirá os
8 bits em dois conjuntos de 4 bits, que irão para a porta AND e de lá para a saída.
</p>
<center><img src="splitter-circ.png" width="351" height="386">
<h5>(Figura do original em inglês)</h5></center>
<p> Nesse exemplo, a distribuição acontecerá na verdade ao se separar um
valor de entrada em vários de saída. Mas os distribuidores também poderão
combinar vários valores em um só. Na verdade, eles não têm direção preferencial:
podem enviar sinais em um sentido em dado instante, e em outro sentido mais tarde,
e ainda poderão fazer as duas coisas ao mesmo tempo, como no exemplo abaixo,
onde um sinal será transmitido para o leste através de dois distribuidores,
e em seguida, será encaminhado de volta para o oeste através deles,
e novamente para leste, onde finalmente chegará a sua saída.
</p>
<center> <img src="splitter-2way.png" width="133" height="63">
<h5>(Figura do original em inglês)</h5></center>
<p> A chave para o entendimento dos distribuidores são seus atributos.
A seguir, o termo <em>terminações (split end)</em> refere-se às múltiplas conexões
de um lado, enquanto o termo <em>combinada (combined)</em> refere-se à extremidade
do único fio do outro lado.
</p>
<ul>
<li> O atributo <strong> Direção (Facing) </strong> dirá a posição relativa das
terminações considerando-se a extremidade combinada.
</li>
<li> O atributo <strong> Distribuição (Fan Out) </strong> especificará quantas
terminações existem.
</li>
<li> O atributo <strong> Largura em Bits à Entrada (Bit Width In) </strong>
especificará a quantidade de bits combinados.
</li>
<li> O atributo <var> Bit <strong> x </var> </strong> dirá qual a terminação
correspondente ao <em> bit x </em> na extremidade combinada. Se vários bits
corresponderem à mesma terminação, então a sua ordem relativa também será a mesma
na extremidade combinada. Os distribuidores do Logisim não poderão ter um bit
na parte combinada que não possua equivalente na parte com múltiplas terminações.
</li>
</ul>
<p> Observar que qualquer alteração nos atributos multiplicidade ou
largura de bit irá recompor todas os atributos <var> Bit x </var>
de modo que eles possam distribuir os bits combinados da maneira mais uniforme
possível entre as terminações.
</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Distribuidores (Splitters)</title>
</head>
<body bgcolor="FFFFFF">
<h1>Distribuidores (Splitters)</h1>
<p> Quando você trabalhar com valores multi-bit, muitas vezes poderá querer rotear
bits em direções diferentes.
A ferramenta Distribuidor (Splitter) da biblioteca Base
(<img Src="../../icons/splitter.gif" width="16" height="16">)
lhe permitirá fazer isso.
</p>
<p> Por exemplo, suponha que queiramos construir um circuito que calcula bit a bit
a conjunção de dois nibbles (meio byte) de uma entrada de oito bits
(os quatro bits superiores e os quatro bits inferiores). Teremos um valor de oito bits
no pinos de entrada, e é desejável dividi-lo em dois valores de quatro bits. No
circuito abaixo, usaremos um distribuidor para conseguir isso: a entrada de 8 bits
irá conectar-se ao distribuidor (que se assemelha a um pé de pássaro), que dividirá os
8 bits em dois conjuntos de 4 bits, que irão para a porta AND e de lá para a saída.
</p>
<center><img src="splitter-circ.png" width="351" height="386">
<h5>(Figura do original em inglês)</h5></center>
<p> Nesse exemplo, a distribuição acontecerá na verdade ao se separar um
valor de entrada em vários de saída. Mas os distribuidores também poderão
combinar vários valores em um só. Na verdade, eles não têm direção preferencial:
podem enviar sinais em um sentido em dado instante, e em outro sentido mais tarde,
e ainda poderão fazer as duas coisas ao mesmo tempo, como no exemplo abaixo,
onde um sinal será transmitido para o leste através de dois distribuidores,
e em seguida, será encaminhado de volta para o oeste através deles,
e novamente para leste, onde finalmente chegará a sua saída.
</p>
<center> <img src="splitter-2way.png" width="133" height="63">
<h5>(Figura do original em inglês)</h5></center>
<p> A chave para o entendimento dos distribuidores são seus atributos.
A seguir, o termo <em>terminações (split end)</em> refere-se às múltiplas conexões
de um lado, enquanto o termo <em>combinada (combined)</em> refere-se à extremidade
do único fio do outro lado.
</p>
<ul>
<li> O atributo <strong> Direção (Facing) </strong> dirá a posição relativa das
terminações considerando-se a extremidade combinada.
</li>
<li> O atributo <strong> Distribuição (Fan Out) </strong> especificará quantas
terminações existem.
</li>
<li> O atributo <strong> Largura em Bits à Entrada (Bit Width In) </strong>
especificará a quantidade de bits combinados.
</li>
<li> O atributo <var> Bit <strong> x </var> </strong> dirá qual a terminação
correspondente ao <em> bit x </em> na extremidade combinada. Se vários bits
corresponderem à mesma terminação, então a sua ordem relativa também será a mesma
na extremidade combinada. Os distribuidores do Logisim não poderão ter um bit
na parte combinada que não possua equivalente na parte com múltiplas terminações.
</li>
</ul>
<p> Observar que qualquer alteração nos atributos multiplicidade ou
largura de bit irá recompor todas os atributos <var> Bit x </var>
de modo que eles possam distribuir os bits combinados da maneira mais uniforme
possível entre as terminações.
</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

124
doc/pt/html/guide/index.html
View File

@ -1,62 +1,62 @@
<html>
<head>
<title>Guia para se tornar usuário do Logisim </title>
</head>
<body bgcolor="FFFFFF">
<h1><em>Guia para se tornar usuário do Logisim</em></h1>
<center><img src="../images/screen-shot.png" width="480" height="303"></center>
<p> Logisim é uma ferramenta educacional para a concepção e a simulação digital
de circuitos lógicos. Com uma interface simples e com ferramentas para simular
circuitos a medida em que são construídos, é simples o bastante para facilitar
a aprendizagem dos conceitos mais básicos relacionados aos circuitos lógicos.
Com a capacidade de construir circuitos maiores a partir de subcircuitos menores,
traçar conexões com um mero arrastar do mouse, o Logisim pode ser usado
(e é usado) para projetar e simular CPUs completas para fins educacionais. </p>
<p> Estudantes em faculdades e universidades de todo o mundo utilizam
Logisim para uma variedade de propósitos, incluindo:
</p>
<ul>
<li> Um módulo </li> para o ensino de ciência da computação em geral
<li> Uma unidade </li> para níveis intermediários em cursos de organização de computadores
<li> Mais do que um semestre inteiro em </li> cursos mais avançados de arquiteturas de computadores.
</ul>
<p> <em> O Guia para tornar um usuário do Logisim </em>, que você está lendo
agora, é a referência oficial para os recursos do Logisim. A primeira parte
é uma sequência de seções que estabelece as principais partes de Logisim. Essas
seções são escritas para que possam ser lidas "de cabo a rabo"
para se tomar conhecimento de todas as características mais importantes do Logisim.
</p>
<blockquote>
<a href="tutorial/index.html"> Tutorial para o iniciante </a>
<br> <a href="attrlib/index.html"> Bibliotecas e atributos </a>
<br> <a href="subcirc/index.html"> Subcircuitos </a>
<br> <a href="bundles/index.html"> Conexões </a>
<br> <a href="analyze/index.html"> Análise combinacional </a>
</blockquote>
<p> As demais seções formam um grupo heterogêneo de materiais de referência
e explicações sobre aspectos menores do Logisim.
</p>
<blockquote>
<a href="menu/index.html"> Menu de referência </a>
<br> <a href="mem/index.html"> Componentes de memória </a>
<br> <a href="log/index.html"> Registro </a>
<br> <a href="verify/index.html"> Verificação por linha de comando </a>
<br> <a href="prefs/index.html"> Preferências da aplicação </a>
<br> <a href="opts/index.html"> Opções de projeto </a>
<br> <a href="prop/index.html"> Propagação de valor </a>
<br> <a href="jar/index.html"> Bibliotecas JAR </a>
<br> <a href="about/index.html"> Sobre o programa </a>
</blockquote>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Guia para se tornar usuário do Logisim </title>
</head>
<body bgcolor="FFFFFF">
<h1><em>Guia para se tornar usuário do Logisim</em></h1>
<center><img src="../images/screen-shot.png" width="480" height="303"></center>
<p> Logisim é uma ferramenta educacional para a concepção e a simulação digital
de circuitos lógicos. Com uma interface simples e com ferramentas para simular
circuitos a medida em que são construídos, é simples o bastante para facilitar
a aprendizagem dos conceitos mais básicos relacionados aos circuitos lógicos.
Com a capacidade de construir circuitos maiores a partir de subcircuitos menores,
traçar conexões com um mero arrastar do mouse, o Logisim pode ser usado
(e é usado) para projetar e simular CPUs completas para fins educacionais. </p>
<p> Estudantes em faculdades e universidades de todo o mundo utilizam
Logisim para uma variedade de propósitos, incluindo:
</p>
<ul>
<li> Um módulo </li> para o ensino de ciência da computação em geral
<li> Uma unidade </li> para níveis intermediários em cursos de organização de computadores
<li> Mais do que um semestre inteiro em </li> cursos mais avançados de arquiteturas de computadores.
</ul>
<p> <em> O Guia para tornar um usuário do Logisim </em>, que você está lendo
agora, é a referência oficial para os recursos do Logisim. A primeira parte
é uma sequência de seções que estabelece as principais partes de Logisim. Essas
seções são escritas para que possam ser lidas "de cabo a rabo"
para se tomar conhecimento de todas as características mais importantes do Logisim.
</p>
<blockquote>
<a href="tutorial/index.html"> Tutorial para o iniciante </a>
<br> <a href="attrlib/index.html"> Bibliotecas e atributos </a>
<br> <a href="subcirc/index.html"> Subcircuitos </a>
<br> <a href="bundles/index.html"> Conexões </a>
<br> <a href="analyze/index.html"> Análise combinacional </a>
</blockquote>
<p> As demais seções formam um grupo heterogêneo de materiais de referência
e explicações sobre aspectos menores do Logisim.
</p>
<blockquote>
<a href="menu/index.html"> Menu de referência </a>
<br> <a href="mem/index.html"> Componentes de memória </a>
<br> <a href="log/index.html"> Registro </a>
<br> <a href="verify/index.html"> Verificação por linha de comando </a>
<br> <a href="prefs/index.html"> Preferências da aplicação </a>
<br> <a href="opts/index.html"> Opções de projeto </a>
<br> <a href="prop/index.html"> Propagação de valor </a>
<br> <a href="jar/index.html"> Bibliotecas JAR </a>
<br> <a href="about/index.html"> Sobre o programa </a>
</blockquote>
</body>
</html>

376
doc/pt/html/guide/jar/counter.html
View File

@ -1,188 +1,188 @@
<html>
<head>
<title>Contador em código de Gray</title>
</head>
<body bgcolor="FFFFFF">
<h1>Contador em código de Gray</h1>
<p> Esta orientação sobre bibliotecas do Logisim apresenta um sofisticado
contador em código de Gray, que permite ao usuário alterar seu valor atual
usando a ferramenta Testar (Poke) e colocar um rótulo sobre o componente
usando a ferramenta de texto (Text Tool). Também personaliza o ícone que
aparece no explorador, associado à ferramenta. </p>
<h2>GrayCounter</h2>
<pre>
package com.cburch.gray;
import java.net.URL;
import javax.swing.ImageIcon;
import com.cburch.logisim.data.Attribute;
import com.cburch.logisim.data.BitWidth;
import com.cburch.logisim.data.Bounds;
import com.cburch.logisim.data.Direction;
import com.cburch.logisim.instance.Instance;
import com.cburch.logisim.instance.InstanceFactory;
import com.cburch.logisim.instance.InstancePainter;
import com.cburch.logisim.instance.InstanceState;
import com.cburch.logisim.instance.Port;
import com.cburch.logisim.instance.StdAttr;
import com.cburch.logisim.util.GraphicsUtil;
import com.cburch.logisim.util.StringUtil;
/** Manufactures a counter that iterates over Gray codes. This demonstrates
* several additional features beyond the SimpleGrayCounter class. */
class GrayCounter extends InstanceFactory {
public GrayCounter() {
super("Gray Counter");
setOffsetBounds(Bounds.create(-30, -15, 30, 30));
setPorts(new Port[] {
new Port(-30, 0, Port.INPUT, 1),
new Port( 0, 0, Port.OUTPUT, StdAttr.WIDTH),
});
// We'll have width, label, and label font attributes. The latter two
// attributes allow us to associate a label with the component (though
// we'll also need configureNewInstance to configure the label's
// location).
setAttributes(
new Attribute[] { StdAttr.WIDTH, StdAttr.LABEL, StdAttr.LABEL_FONT },
new Object[] { BitWidth.create(4), "", StdAttr.DEFAULT_LABEL_FONT });
// The following method invocation sets things up so that the instance's
// state can be manipulated using the Poke Tool.
setInstancePoker(CounterPoker.class);
// These next two lines set it up so that the explorer window shows a
// customized icon representing the component type. This should be a
// 16x16 image.
URL url = getClass().getClassLoader().getResource("com/cburch/gray/counter.gif");
if(url != null) setIcon(new ImageIcon(url));
}
/** The configureNewInstance method is invoked every time a new instance
* is created. In the superclass, the method doesn't do anything, since
* the new instance is pretty thoroughly configured already by default. But
* sometimes you need to do something particular to each instance, so you
* would override the method. In this case, we need to set up the location
* for its label. */
protected void configureNewInstance(Instance instance) {
Bounds bds = instance.getBounds();
instance.setTextField(StdAttr.LABEL, StdAttr.LABEL_FONT,
bds.getX() + bds.getWidth() / 2, bds.getY() - 3,
GraphicsUtil.H_CENTER, GraphicsUtil.V_BASELINE);
}
public void propagate(InstanceState state) {
// This is the same as with SimpleGrayCounter, except that we use the
// StdAttr.WIDTH attribute to determine the bit width to work with.
BitWidth width = state.getAttributeValue(StdAttr.WIDTH);
CounterData cur = CounterData.get(state, width);
boolean trigger = cur.updateClock(state.getPort(0));
if(trigger) cur.setValue(GrayIncrementer.nextGray(cur.getValue()));
state.setPort(1, cur.getValue(), 9);
}
public void paintInstance(InstancePainter painter) {
// This is essentially the same as with SimpleGrayCounter, except for
// the invocation of painter.drawLabel to make the label be drawn.
painter.drawBounds();
painter.drawClock(0, Direction.EAST);
painter.drawPort(1);
painter.drawLabel();
if(painter.getShowState()) {
BitWidth width = painter.getAttributeValue(StdAttr.WIDTH);
CounterData state = CounterData.get(painter, width);
Bounds bds = painter.getBounds();
GraphicsUtil.drawCenteredText(painter.getGraphics(),
StringUtil.toHexString(width.getWidth(), state.getValue().toIntValue()),
bds.getX() + bds.getWidth() / 2,
bds.getY() + bds.getHeight() / 2);
}
}
}
</pre>
<h2>CounterPoker</h2>
<pre>
package com.cburch.gray;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import com.cburch.logisim.data.BitWidth;
import com.cburch.logisim.data.Bounds;
import com.cburch.logisim.data.Value;
import com.cburch.logisim.instance.InstancePainter;
import com.cburch.logisim.instance.InstancePoker;
import com.cburch.logisim.instance.InstanceState;
import com.cburch.logisim.instance.StdAttr;
/** When the user clicks a counter using the Poke Tool, a CounterPoker object
* is created, and that object will handle all user events. Note that
* CounterPoker is a class specific to GrayCounter, and that it must be a
* subclass of InstancePoker in the com.cburch.logisim.instance package. */
public class CounterPoker extends InstancePoker {
public CounterPoker() { }
/** Determines whether the location the mouse was pressed should result
* in initiating a poke.
*/
public boolean init(InstanceState state, MouseEvent e) {
return state.getInstance().getBounds().contains(e.getX(), e.getY());
// Anywhere in the main rectangle initiates the poke. The user might
// have clicked within a label, but that will be outside the bounds.
}
/** Draws an indicator that the caret is being selected. Here, we'll draw
* a red rectangle around the value. */
public void paint(InstancePainter painter) {
Bounds bds = painter.getBounds();
BitWidth width = painter.getAttributeValue(StdAttr.WIDTH);
int len = (width.getWidth() + 3) / 4;
Graphics g = painter.getGraphics();
g.setColor(Color.RED);
int wid = 7 * len + 2; // width of caret rectangle
int ht = 16; // height of caret rectangle
g.drawRect(bds.getX() + (bds.getWidth() - wid) / 2,
bds.getY() + (bds.getHeight() - ht) / 2, wid, ht);
g.setColor(Color.BLACK);
}
/** Processes a key by just adding it onto the end of the current value. */
public void keyTyped(InstanceState state, KeyEvent e) {
// convert it to a hex digit; if it isn't a hex digit, abort.
int val = Character.digit(e.getKeyChar(), 16);
BitWidth width = state.getAttributeValue(StdAttr.WIDTH);
if(val < 0 || (val & width.getMask()) != val) return;
// compute the next value
CounterData cur = CounterData.get(state, width);
int newVal = (cur.getValue().toIntValue() * 16 + val) & width.getMask();
Value newValue = Value.createKnown(width, newVal);
cur.setValue(newValue);
state.fireInvalidated();
// You might be tempted to propagate the value immediately here, using
// state.setPort. However, the circuit may currently be propagating in
// another thread, and invoking setPort directly could interfere with
// that. Using fireInvalidated notifies the propagation thread to
// invoke propagate on the counter at its next opportunity.
}
}
</pre>
<p><strong>Próximo:</strong> <a href="guide.html">Orientações</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Contador em código de Gray</title>
</head>
<body bgcolor="FFFFFF">
<h1>Contador em código de Gray</h1>
<p> Esta orientação sobre bibliotecas do Logisim apresenta um sofisticado
contador em código de Gray, que permite ao usuário alterar seu valor atual
usando a ferramenta Testar (Poke) e colocar um rótulo sobre o componente
usando a ferramenta de texto (Text Tool). Também personaliza o ícone que
aparece no explorador, associado à ferramenta. </p>
<h2>GrayCounter</h2>
<pre>
package com.cburch.gray;
import java.net.URL;
import javax.swing.ImageIcon;
import com.cburch.logisim.data.Attribute;
import com.cburch.logisim.data.BitWidth;
import com.cburch.logisim.data.Bounds;
import com.cburch.logisim.data.Direction;
import com.cburch.logisim.instance.Instance;
import com.cburch.logisim.instance.InstanceFactory;
import com.cburch.logisim.instance.InstancePainter;
import com.cburch.logisim.instance.InstanceState;
import com.cburch.logisim.instance.Port;
import com.cburch.logisim.instance.StdAttr;
import com.cburch.logisim.util.GraphicsUtil;
import com.cburch.logisim.util.StringUtil;
/** Manufactures a counter that iterates over Gray codes. This demonstrates
* several additional features beyond the SimpleGrayCounter class. */
class GrayCounter extends InstanceFactory {
public GrayCounter() {
super("Gray Counter");
setOffsetBounds(Bounds.create(-30, -15, 30, 30));
setPorts(new Port[] {
new Port(-30, 0, Port.INPUT, 1),
new Port( 0, 0, Port.OUTPUT, StdAttr.WIDTH),
});
// We'll have width, label, and label font attributes. The latter two
// attributes allow us to associate a label with the component (though
// we'll also need configureNewInstance to configure the label's
// location).
setAttributes(
new Attribute[] { StdAttr.WIDTH, StdAttr.LABEL, StdAttr.LABEL_FONT },
new Object[] { BitWidth.create(4), "", StdAttr.DEFAULT_LABEL_FONT });
// The following method invocation sets things up so that the instance's
// state can be manipulated using the Poke Tool.
setInstancePoker(CounterPoker.class);
// These next two lines set it up so that the explorer window shows a
// customized icon representing the component type. This should be a
// 16x16 image.
URL url = getClass().getClassLoader().getResource("com/cburch/gray/counter.gif");
if(url != null) setIcon(new ImageIcon(url));
}
/** The configureNewInstance method is invoked every time a new instance
* is created. In the superclass, the method doesn't do anything, since
* the new instance is pretty thoroughly configured already by default. But
* sometimes you need to do something particular to each instance, so you
* would override the method. In this case, we need to set up the location
* for its label. */
protected void configureNewInstance(Instance instance) {
Bounds bds = instance.getBounds();
instance.setTextField(StdAttr.LABEL, StdAttr.LABEL_FONT,
bds.getX() + bds.getWidth() / 2, bds.getY() - 3,
GraphicsUtil.H_CENTER, GraphicsUtil.V_BASELINE);
}
public void propagate(InstanceState state) {
// This is the same as with SimpleGrayCounter, except that we use the
// StdAttr.WIDTH attribute to determine the bit width to work with.
BitWidth width = state.getAttributeValue(StdAttr.WIDTH);
CounterData cur = CounterData.get(state, width);
boolean trigger = cur.updateClock(state.getPort(0));
if(trigger) cur.setValue(GrayIncrementer.nextGray(cur.getValue()));
state.setPort(1, cur.getValue(), 9);
}
public void paintInstance(InstancePainter painter) {
// This is essentially the same as with SimpleGrayCounter, except for
// the invocation of painter.drawLabel to make the label be drawn.
painter.drawBounds();
painter.drawClock(0, Direction.EAST);
painter.drawPort(1);
painter.drawLabel();
if(painter.getShowState()) {
BitWidth width = painter.getAttributeValue(StdAttr.WIDTH);
CounterData state = CounterData.get(painter, width);
Bounds bds = painter.getBounds();
GraphicsUtil.drawCenteredText(painter.getGraphics(),
StringUtil.toHexString(width.getWidth(), state.getValue().toIntValue()),
bds.getX() + bds.getWidth() / 2,
bds.getY() + bds.getHeight() / 2);
}
}
}
</pre>
<h2>CounterPoker</h2>
<pre>
package com.cburch.gray;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import com.cburch.logisim.data.BitWidth;
import com.cburch.logisim.data.Bounds;
import com.cburch.logisim.data.Value;
import com.cburch.logisim.instance.InstancePainter;
import com.cburch.logisim.instance.InstancePoker;
import com.cburch.logisim.instance.InstanceState;
import com.cburch.logisim.instance.StdAttr;
/** When the user clicks a counter using the Poke Tool, a CounterPoker object
* is created, and that object will handle all user events. Note that
* CounterPoker is a class specific to GrayCounter, and that it must be a
* subclass of InstancePoker in the com.cburch.logisim.instance package. */
public class CounterPoker extends InstancePoker {
public CounterPoker() { }
/** Determines whether the location the mouse was pressed should result
* in initiating a poke.
*/
public boolean init(InstanceState state, MouseEvent e) {
return state.getInstance().getBounds().contains(e.getX(), e.getY());
// Anywhere in the main rectangle initiates the poke. The user might
// have clicked within a label, but that will be outside the bounds.
}
/** Draws an indicator that the caret is being selected. Here, we'll draw
* a red rectangle around the value. */
public void paint(InstancePainter painter) {
Bounds bds = painter.getBounds();
BitWidth width = painter.getAttributeValue(StdAttr.WIDTH);
int len = (width.getWidth() + 3) / 4;
Graphics g = painter.getGraphics();
g.setColor(Color.RED);
int wid = 7 * len + 2; // width of caret rectangle
int ht = 16; // height of caret rectangle
g.drawRect(bds.getX() + (bds.getWidth() - wid) / 2,
bds.getY() + (bds.getHeight() - ht) / 2, wid, ht);
g.setColor(Color.BLACK);
}
/** Processes a key by just adding it onto the end of the current value. */
public void keyTyped(InstanceState state, KeyEvent e) {
// convert it to a hex digit; if it isn't a hex digit, abort.
int val = Character.digit(e.getKeyChar(), 16);
BitWidth width = state.getAttributeValue(StdAttr.WIDTH);
if(val < 0 || (val & width.getMask()) != val) return;
// compute the next value
CounterData cur = CounterData.get(state, width);
int newVal = (cur.getValue().toIntValue() * 16 + val) & width.getMask();
Value newValue = Value.createKnown(width, newVal);
cur.setValue(newValue);
state.fireInvalidated();
// You might be tempted to propagate the value immediately here, using
// state.setPort. However, the circuit may currently be propagating in
// another thread, and invoking setPort directly could interfere with
// that. Using fireInvalidated notifies the propagation thread to
// invoke propagate on the counter at its next opportunity.
}
}
</pre>
<p><strong>Próximo:</strong> <a href="guide.html">Orientações</a>.</p>
</body>
</html>

94
doc/pt/html/guide/jar/guide.html
View File

@ -1,47 +1,47 @@
<html>
<head>
<title>Orientações</title>
</head>
<body bgcolor="FFFFFF">
<h1>Orientações</h1>
<h2>Aprender mais</h2>
<p> Além da sequência de exemplos apresentados aqui, o código-fonte do Logisim
fornece exemplos adicionais, embora nem sempre eles ilustrem
a mesma atenção para com a legibilidade e o bom <i>design</i>.
</p>
<p> Para maior portabilidade considerando versões futuras, você deverá manter
tanto quanto possível as classes em pacotes de ... <code> instâncias </code>,
... <code> dados </code>, e ... <code> ferramentas </code>. Claro, você poderá usar
outras APIs, mas elas poderão ser mais vulneráveis às alterações futuras.
</p>
<p> Em geral, estou disposto a responder a eventuais pedidos de ajuda. Relatórios
com <i>bugs</i> e sugestões de melhorias, é claro, serão sempre bem vindos.
</p>
<h2> Distribuição </h2>
<p> Você é livre para distribuir qualquer arquivo JAR que desenvolver, sem restrições.
As restrições GPL se aplicarão, porém, se trechos de seu trabalho forem
derivados de partes do código-fonte do Logisim (liberado sob a GPL).
Derivações do código de exemplo nesta seção do <em> Guia do Usuário </em>
não incorrem em tais restrições, esses exemplos estão cobertos nos termos da
licença do MIT.
</p>
<p> Se você quiser de compartilhar sua biblioteca com outros usuários Logisim,
estarei disposto a fornecer um <i>link</i> para uma página Web de hospedagem ou para
o arquivo JAR através do <i>site</i> do Logisim. Se você achar que sua biblioteca
deverá ser incorporada à distribuição básica do Logisim, então também me
congratularei com a sua sugestão, e terei prazer em reconhecer sua contribuição
em futuros lançamentos do Logisim, que incluírem o trabalho.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Orientações</title>
</head>
<body bgcolor="FFFFFF">
<h1>Orientações</h1>
<h2>Aprender mais</h2>
<p> Além da sequência de exemplos apresentados aqui, o código-fonte do Logisim
fornece exemplos adicionais, embora nem sempre eles ilustrem
a mesma atenção para com a legibilidade e o bom <i>design</i>.
</p>
<p> Para maior portabilidade considerando versões futuras, você deverá manter
tanto quanto possível as classes em pacotes de ... <code> instâncias </code>,
... <code> dados </code>, e ... <code> ferramentas </code>. Claro, você poderá usar
outras APIs, mas elas poderão ser mais vulneráveis às alterações futuras.
</p>
<p> Em geral, estou disposto a responder a eventuais pedidos de ajuda. Relatórios
com <i>bugs</i> e sugestões de melhorias, é claro, serão sempre bem vindos.
</p>
<h2> Distribuição </h2>
<p> Você é livre para distribuir qualquer arquivo JAR que desenvolver, sem restrições.
As restrições GPL se aplicarão, porém, se trechos de seu trabalho forem
derivados de partes do código-fonte do Logisim (liberado sob a GPL).
Derivações do código de exemplo nesta seção do <em> Guia do Usuário </em>
não incorrem em tais restrições, esses exemplos estão cobertos nos termos da
licença do MIT.
</p>
<p> Se você quiser de compartilhar sua biblioteca com outros usuários Logisim,
estarei disposto a fornecer um <i>link</i> para uma página Web de hospedagem ou para
o arquivo JAR através do <i>site</i> do Logisim. Se você achar que sua biblioteca
deverá ser incorporada à distribuição básica do Logisim, então também me
congratularei com a sua sugestão, e terei prazer em reconhecer sua contribuição
em futuros lançamentos do Logisim, que incluírem o trabalho.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>

446
doc/pt/html/guide/jar/incr.html
View File

@ -1,223 +1,223 @@
<html>
<head>
<title>Incrementador em código de Gray</title>
</head>
<body bgcolor="FFFFFF">
<h1>Incrementador em código de Gray</h1>
<p> Cada componente incluído em uma biblioteca é definido através da criação de
uma subclasse de <code> InstanceFactory </code> encontrada no pacote
<code> com.cburch.logisim.instance</code>. Esta subclasse tem todo
o código necessário.
</p>
<p> (Aqui descreveremos a API para a versão atual do Logisim.
Você poderá encontrar algumas bibliotecas desenvolvidas para versões anteriores
do Logisim, para componentes que foram desenvolvidos através da definição de duas
classes, uma extensão <code> Component </code> e outra que estende
<code> ComponentFactory</code>.
Versão 2.3.0 introduziu uma API muito mais simples a <code> InstanceFactory</code>,
a técnica anterior está obsoleta.)
</p>
<p> Três pacotes do Logisim resumem a maioria das classes relevantes para a definição
bibliotecas de componentes.
</p>
<dl>
<dt> <code> com.cburch.logisim.instance </code> </dt>
<dd> <p> Contém classes especificamente relacionadas com a definição de componentes,
incluindo as classes <code> InstanceFactory</code>, <code> InstanceState</code>,
<code> InstancePainter</code> e <code> Instance</code>.
</p> </dd>
<dt> <code> com.cburch.logisim.data </code> </dt>
<dd> <p> Contém classes relacionadas com os elementos de dados associados aos
componentes, como a classe <code> Bounds </code> para representar retângulos limítrofes,
ou a classe <code> Value </code> para representar os valores que possam
existir em uma conexão.
</p> </dd>
<dt> <code> com.cburch.logisim.tools </code> </dt>
<dd> <p> Contém classes relacionadas com a definição da biblioteca.
</p> </dd>
</dl>
<h2> Acerca dos códigos de Gray </h2>
<p> Antes de prosseguir, descreverei brevemente o código Gray em que estes
exemplos se baseiam. Não é realmente importante para se entender como esses
exemplos funcionam, assim você poderá pular para o código abaixo, se desejar -
especialmente se você já conhecer os códigos de Gray.
</p>
<p> O código de Gray é uma técnica (em homenagem a Frank Gray) para iterar
<var> n </var> sequências de bits com apenas uma ligeira modificação em cada etapa.
Como exemplo, considere os 4 bits do código de Gray listados abaixo. </p>
<blockquote><table><tbody>
<tr><td valign="top">000<u>0</u>
<br>00<u>0</u>1
<br>001<u>1</u>
<br>0<u>0</u>10
</td><td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</td><td valign="top">011<u>0</u>
<br>01<u>1</u>1
<br>010<u>1</u>
<br><u>0</u>100
</td><td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</td><td valign="top">110<u>0</u>
<br>11<u>0</u>1
<br>111<u>1</u>
<br>1<u>1</u>10
</td><td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</td><td valign="top">101<u>0</u>
<br>10<u>1</u>1
<br>100<u>1</u>
<br><u>1</u>000
</td></tr></tbody></table></blockquote>
<p> Cada valor tem o bit sublinhado que irá mudar no próximo valor da
sequência. Por exemplo, depois de 0000 virá 0001, no qual o bit final foi
alterado, por isso o último bit será sublinhado.
</p>
<p> Os componentes predefinidos do Logisim não incluem recurso para se trabalhar
com códigos de Gray.
Porém, os projetistas eletrônicos consideram os códigos de Gray úteis às vezes. Um
exemplo de aplicação particularmente notável dos códigos de Gray é sobre os eixos em
mapas de Karnaugh.
</p>
<h2> GrayIncrementer </h2>
<p> Este é um pequeno exemplo que ilustra os elementos essenciais para se definir
um componente. Esse componente em particular é um incrementador,
que tem uma entrada multibit e produz o código de Gray imediatamente seguinte a ele
em sequência.
</p>
<pre>
package com.cburch.gray;
import com.cburch.logisim.data.Attribute;
import com.cburch.logisim.data.BitWidth;
import com.cburch.logisim.data.Bounds;
import com.cburch.logisim.data.Value;
import com.cburch.logisim.instance.InstanceFactory;
import com.cburch.logisim.instance.InstancePainter;
import com.cburch.logisim.instance.InstanceState;
import com.cburch.logisim.instance.Port;
import com.cburch.logisim.instance.StdAttr;
/** This component takes a multibit input and outputs the value that follows it
* in Gray Code. For instance, given input 0100 the output is 1100. */
class GrayIncrementer extends InstanceFactory {
/* Note that there are no instance variables. There is only one instance of
* this class created, which manages all instances of the component. Any
* information associated with individual instances should be handled
* through attributes. For GrayIncrementer, each instance has a "bit width"
* that it works with, and so we'll have an attribute. */
/** The constructor configures the factory. */
GrayIncrementer() {
super("Gray Code Incrementer");
/* This is how we can set up the attributes for GrayIncrementers. In
* this case, there is just one attribute - the width - whose default
* is 4. The StdAttr class defines several commonly occurring
* attributes, including one for "bit width." It's best to use those
* StdAttr attributes when appropriate: A user can then select several
* components (even from differing factories) with the same attribute
* and modify them all at once. */
setAttributes(new Attribute[] { StdAttr.WIDTH },
new Object[] { BitWidth.create(4) });
/* The "offset bounds" is the location of the bounding rectangle
* relative to the mouse location. Here, we're choosing the component to
* be 30x30, and we're anchoring it relative to its primary output
* (as is typical for Logisim), which happens to be in the center of the
* east edge. Thus, the top left corner of the bounding box is 30 pixels
* west and 15 pixels north of the mouse location. */
setOffsetBounds(Bounds.create(-30, -15, 30, 30));
/* The ports are locations where wires can be connected to this
* component. Each port object says where to find the port relative to
* the component's anchor location, then whether the port is an
* input/output/both, and finally the expected bit width for the port.
* The bit width can be a constant (like 1) or an attribute (as here).
*/
setPorts(new Port[] {
new Port(-30, 0, Port.INPUT, StdAttr.WIDTH),
new Port(0, 0, Port.OUTPUT, StdAttr.WIDTH),
});
}
/** Computes the current output for this component. This method is invoked
* any time any of the inputs change their values; it may also be invoked in
* other circumstances, even if there is no reason to expect it to change
* anything. */
public void propagate(InstanceState state) {
// First we retrieve the value being fed into the input. Note that in
// the setPorts invocation above, the component's input was included at
// index 0 in the parameter array, so we use 0 as the parameter below.
Value in = state.getPort(0);
// Now compute the output. We've farmed this out to a helper method,
// since the same logic is needed for the library's other components.
Value out = nextGray(in);
// Finally we propagate the output into the circuit. The first parameter
// is 1 because in our list of ports (configured by invocation of
// setPorts above) the output is at index 1. The second parameter is the
// value we want to send on that port. And the last parameter is its
// "delay" - the number of steps it will take for the output to update
// after its input.
state.setPort(1, out, out.getWidth() + 1);
}
/** Says how an individual instance should appear on the canvas. */
public void paintInstance(InstancePainter painter) {
// As it happens, InstancePainter contains several convenience methods
// for drawing, and we'll use those here. Frequently, you'd want to
// retrieve its Graphics object (painter.getGraphics) so you can draw
// directly onto the canvas.
painter.drawRectangle(painter.getBounds(), "G+1");
painter.drawPorts();
}
/** Computes the next gray value in the sequence after prev. This static
* method just does some bit twiddling; it doesn't have much to do with
* Logisim except that it manipulates Value and BitWidth objects. */
static Value nextGray(Value prev) {
BitWidth bits = prev.getBitWidth();
if(!prev.isFullyDefined()) return Value.createError(bits);
int x = prev.toIntValue();
int ct = (x >> 16) ^ x; // compute parity of x
ct = (ct >> 8) ^ ct;
ct = (ct >> 4) ^ ct;
ct = (ct >> 2) ^ ct;
ct = (ct >> 1) ^ ct;
if((ct & 1) == 0) { // if parity is even, flip 1's bit
x = x ^ 1;
} else { // else flip bit just above last 1
int y = x ^ (x & (x - 1)); // first compute the last 1
y = (y << 1) & bits.getMask();
x = (y == 0 ? 0 : x ^ y);
}
return Value.createKnown(bits, x);
}
}
</pre>
<p> Este exemplo, por si só não é suficiente para se criar um arquivo JAR funcional;
você também deverá prover uma classe Library, conforme ilustrado na página a seguir.
</p>
<p><strong>Próximo:</strong> <a href="library.html">Classe Library</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Incrementador em código de Gray</title>
</head>
<body bgcolor="FFFFFF">
<h1>Incrementador em código de Gray</h1>
<p> Cada componente incluído em uma biblioteca é definido através da criação de
uma subclasse de <code> InstanceFactory </code> encontrada no pacote
<code> com.cburch.logisim.instance</code>. Esta subclasse tem todo
o código necessário.
</p>
<p> (Aqui descreveremos a API para a versão atual do Logisim.
Você poderá encontrar algumas bibliotecas desenvolvidas para versões anteriores
do Logisim, para componentes que foram desenvolvidos através da definição de duas
classes, uma extensão <code> Component </code> e outra que estende
<code> ComponentFactory</code>.
Versão 2.3.0 introduziu uma API muito mais simples a <code> InstanceFactory</code>,
a técnica anterior está obsoleta.)
</p>
<p> Três pacotes do Logisim resumem a maioria das classes relevantes para a definição
bibliotecas de componentes.
</p>
<dl>
<dt> <code> com.cburch.logisim.instance </code> </dt>
<dd> <p> Contém classes especificamente relacionadas com a definição de componentes,
incluindo as classes <code> InstanceFactory</code>, <code> InstanceState</code>,
<code> InstancePainter</code> e <code> Instance</code>.
</p> </dd>
<dt> <code> com.cburch.logisim.data </code> </dt>
<dd> <p> Contém classes relacionadas com os elementos de dados associados aos
componentes, como a classe <code> Bounds </code> para representar retângulos limítrofes,
ou a classe <code> Value </code> para representar os valores que possam
existir em uma conexão.
</p> </dd>
<dt> <code> com.cburch.logisim.tools </code> </dt>
<dd> <p> Contém classes relacionadas com a definição da biblioteca.
</p> </dd>
</dl>
<h2> Acerca dos códigos de Gray </h2>
<p> Antes de prosseguir, descreverei brevemente o código Gray em que estes
exemplos se baseiam. Não é realmente importante para se entender como esses
exemplos funcionam, assim você poderá pular para o código abaixo, se desejar -
especialmente se você já conhecer os códigos de Gray.
</p>
<p> O código de Gray é uma técnica (em homenagem a Frank Gray) para iterar
<var> n </var> sequências de bits com apenas uma ligeira modificação em cada etapa.
Como exemplo, considere os 4 bits do código de Gray listados abaixo. </p>
<blockquote><table><tbody>
<tr><td valign="top">000<u>0</u>
<br>00<u>0</u>1
<br>001<u>1</u>
<br>0<u>0</u>10
</td><td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</td><td valign="top">011<u>0</u>
<br>01<u>1</u>1
<br>010<u>1</u>
<br><u>0</u>100
</td><td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</td><td valign="top">110<u>0</u>
<br>11<u>0</u>1
<br>111<u>1</u>
<br>1<u>1</u>10
</td><td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</td><td valign="top">101<u>0</u>
<br>10<u>1</u>1
<br>100<u>1</u>
<br><u>1</u>000
</td></tr></tbody></table></blockquote>
<p> Cada valor tem o bit sublinhado que irá mudar no próximo valor da
sequência. Por exemplo, depois de 0000 virá 0001, no qual o bit final foi
alterado, por isso o último bit será sublinhado.
</p>
<p> Os componentes predefinidos do Logisim não incluem recurso para se trabalhar
com códigos de Gray.
Porém, os projetistas eletrônicos consideram os códigos de Gray úteis às vezes. Um
exemplo de aplicação particularmente notável dos códigos de Gray é sobre os eixos em
mapas de Karnaugh.
</p>
<h2> GrayIncrementer </h2>
<p> Este é um pequeno exemplo que ilustra os elementos essenciais para se definir
um componente. Esse componente em particular é um incrementador,
que tem uma entrada multibit e produz o código de Gray imediatamente seguinte a ele
em sequência.
</p>
<pre>
package com.cburch.gray;
import com.cburch.logisim.data.Attribute;
import com.cburch.logisim.data.BitWidth;
import com.cburch.logisim.data.Bounds;
import com.cburch.logisim.data.Value;
import com.cburch.logisim.instance.InstanceFactory;
import com.cburch.logisim.instance.InstancePainter;
import com.cburch.logisim.instance.InstanceState;
import com.cburch.logisim.instance.Port;
import com.cburch.logisim.instance.StdAttr;
/** This component takes a multibit input and outputs the value that follows it
* in Gray Code. For instance, given input 0100 the output is 1100. */
class GrayIncrementer extends InstanceFactory {
/* Note that there are no instance variables. There is only one instance of
* this class created, which manages all instances of the component. Any
* information associated with individual instances should be handled
* through attributes. For GrayIncrementer, each instance has a "bit width"
* that it works with, and so we'll have an attribute. */
/** The constructor configures the factory. */
GrayIncrementer() {
super("Gray Code Incrementer");
/* This is how we can set up the attributes for GrayIncrementers. In
* this case, there is just one attribute - the width - whose default
* is 4. The StdAttr class defines several commonly occurring
* attributes, including one for "bit width." It's best to use those
* StdAttr attributes when appropriate: A user can then select several
* components (even from differing factories) with the same attribute
* and modify them all at once. */
setAttributes(new Attribute[] { StdAttr.WIDTH },
new Object[] { BitWidth.create(4) });
/* The "offset bounds" is the location of the bounding rectangle
* relative to the mouse location. Here, we're choosing the component to
* be 30x30, and we're anchoring it relative to its primary output
* (as is typical for Logisim), which happens to be in the center of the
* east edge. Thus, the top left corner of the bounding box is 30 pixels
* west and 15 pixels north of the mouse location. */
setOffsetBounds(Bounds.create(-30, -15, 30, 30));
/* The ports are locations where wires can be connected to this
* component. Each port object says where to find the port relative to
* the component's anchor location, then whether the port is an
* input/output/both, and finally the expected bit width for the port.
* The bit width can be a constant (like 1) or an attribute (as here).
*/
setPorts(new Port[] {
new Port(-30, 0, Port.INPUT, StdAttr.WIDTH),
new Port(0, 0, Port.OUTPUT, StdAttr.WIDTH),
});
}
/** Computes the current output for this component. This method is invoked
* any time any of the inputs change their values; it may also be invoked in
* other circumstances, even if there is no reason to expect it to change
* anything. */
public void propagate(InstanceState state) {
// First we retrieve the value being fed into the input. Note that in
// the setPorts invocation above, the component's input was included at
// index 0 in the parameter array, so we use 0 as the parameter below.
Value in = state.getPort(0);
// Now compute the output. We've farmed this out to a helper method,
// since the same logic is needed for the library's other components.
Value out = nextGray(in);
// Finally we propagate the output into the circuit. The first parameter
// is 1 because in our list of ports (configured by invocation of
// setPorts above) the output is at index 1. The second parameter is the
// value we want to send on that port. And the last parameter is its
// "delay" - the number of steps it will take for the output to update
// after its input.
state.setPort(1, out, out.getWidth() + 1);
}
/** Says how an individual instance should appear on the canvas. */
public void paintInstance(InstancePainter painter) {
// As it happens, InstancePainter contains several convenience methods
// for drawing, and we'll use those here. Frequently, you'd want to
// retrieve its Graphics object (painter.getGraphics) so you can draw
// directly onto the canvas.
painter.drawRectangle(painter.getBounds(), "G+1");
painter.drawPorts();
}
/** Computes the next gray value in the sequence after prev. This static
* method just does some bit twiddling; it doesn't have much to do with
* Logisim except that it manipulates Value and BitWidth objects. */
static Value nextGray(Value prev) {
BitWidth bits = prev.getBitWidth();
if(!prev.isFullyDefined()) return Value.createError(bits);
int x = prev.toIntValue();
int ct = (x >> 16) ^ x; // compute parity of x
ct = (ct >> 8) ^ ct;
ct = (ct >> 4) ^ ct;
ct = (ct >> 2) ^ ct;
ct = (ct >> 1) ^ ct;
if((ct & 1) == 0) { // if parity is even, flip 1's bit
x = x ^ 1;
} else { // else flip bit just above last 1
int y = x ^ (x & (x - 1)); // first compute the last 1
y = (y << 1) & bits.getMask();
x = (y == 0 ? 0 : x ^ y);
}
return Value.createKnown(bits, x);
}
}
</pre>
<p> Este exemplo, por si só não é suficiente para se criar um arquivo JAR funcional;
você também deverá prover uma classe Library, conforme ilustrado na página a seguir.
</p>
<p><strong>Próximo:</strong> <a href="library.html">Classe Library</a>.</p>
</body>
</html>

214
doc/pt/html/guide/jar/index.html
View File

@ -1,107 +1,107 @@
<html>
<head>
<title>Bibliotecas JAR</title>
</head>
<body bgcolor="FFFFFF">
<h1>Bibliotecas JAR</h1>
<h2>Uso de bibliotecas JAR</h2>
<p> O Logisim tem dois tipos de componentes de circuito: os que
são concebidos dentro Logisim como combinações de outros; e os primitivos,
que são escritos em Java. Os circuitos do Logisim são mais fáceis de projetar,
mas eles não podem oferecer suporte mais sofisticado à interação com o usuário,
e são relativamente ineficientes.
</p>
<p> O Logisim contém uma coleção bastante completa de bibliotecas predefinidas
de componentes em Java, mas poderá também acomodar bibliotecas adicionais escritas
por você ou por outros. Uma vez em posse do código de uma biblioteca, você poderá
importá-lo em seu projeto ao clicar em Projeto no painel de explorador (linha superior)
e escolher carregar a biblioteca (Load Library > JAR Library)... Então, o Logisim
pedirá para você selecionar o arquivo JAR.
(Em algumas circunstâncias, você poderá ter que digitar o nome da classe inicial,
quando solicitado, isso deverá ser previsto pelo desenvolvedor da biblioteca.
No entanto, um desenvolvedor normalmente deverá configurar a biblioteca JAR para
evitar isso (ao incluir no <q> manifesto </q> do arquivo JAR um atributo
Library-Class especificando o principal nome da classe).)
</p>
<h2>Criar bibliotecas JAR</h2>
<p> O restante desta seção será dedicado a uma série de exemplos
bem comentados que ilustram como desenvolver bibliotecas do Logisim.
Você só deverá tentar fazer isso, se for um programador Java experiente.
Além desses exemplos, você irá encontrar documentação bastante escassa.
</p>
Você poderá baixar um arquivo JAR que lhe permitirá importar esses exemplos
do <i>website</i> do Logisim na seção Links. Esse arquivo JAR também conterá
o código-fonte desses exemplos.
</p>
<dl>
<dt> <a href="incr.html"> Incrementador em código de Gray</a> </dt>
<dd> <p> Ilustra os elementos essenciais de qualquer tipo de componente
por meio de um exemplo simples de um componente que tem uma entrada multibit
e calcula o valor do próximo código de Gray que o segue.
</p> </dd>
<dt> <a href="library.html"> Biblioteca de classes </a> </dt>
<dd> <p> Ilustra como definir uma biblioteca. Este é o ponto de entrada
para qualquer arquivo JAR - a classe cujo nome o usuário fornecerá quando
for carregar a biblioteca JAR.
</p> </dd>
<a <dt> href="simpctr.html"> Contador simples em código Gray </a> </dt>
<dd> <p> Ilustra como fazer um componente que tem estado interno;
em particular, um contador de 8 bits que itera em código de Gray.
</p> </dd>
<dt> <a href="counter.html"> Contador em código de Gray </a> </dt>
<dd> <p> Demonstra um componente completo, bem mais sofisticado, com o qual
o usuário poderá interagir. Ele implementa um contador em código de Gray, onde o
número de bits guardado é customizável, e onde o usuário poderá editar o valor
corrente, ao clicar nele com a ferramenta Testar e digitar um novo valor.
</p>
<a <dt> href="guide.html"> Orientações </a>
<dd> Informações gerais para as bibliotecas com desenvolvimento por terceiros. </p>
</dl>
<h2>License</h2>
<p>The code in this example JAR library is released under the MIT license,
a more permissive license than the GPL, under which the rest of Logisim is
released.</p>
<p>Copyright (c) 2009, Carl Burch.</p>
<p>Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:</p>
<p>The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.</p>
<p>THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.</p>
<p><strong>Próximo:</strong> <a href="incr.html">Incrementador em código de Gray</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Bibliotecas JAR</title>
</head>
<body bgcolor="FFFFFF">
<h1>Bibliotecas JAR</h1>
<h2>Uso de bibliotecas JAR</h2>
<p> O Logisim tem dois tipos de componentes de circuito: os que
são concebidos dentro Logisim como combinações de outros; e os primitivos,
que são escritos em Java. Os circuitos do Logisim são mais fáceis de projetar,
mas eles não podem oferecer suporte mais sofisticado à interação com o usuário,
e são relativamente ineficientes.
</p>
<p> O Logisim contém uma coleção bastante completa de bibliotecas predefinidas
de componentes em Java, mas poderá também acomodar bibliotecas adicionais escritas
por você ou por outros. Uma vez em posse do código de uma biblioteca, você poderá
importá-lo em seu projeto ao clicar em Projeto no painel de explorador (linha superior)
e escolher carregar a biblioteca (Load Library > JAR Library)... Então, o Logisim
pedirá para você selecionar o arquivo JAR.
(Em algumas circunstâncias, você poderá ter que digitar o nome da classe inicial,
quando solicitado, isso deverá ser previsto pelo desenvolvedor da biblioteca.
No entanto, um desenvolvedor normalmente deverá configurar a biblioteca JAR para
evitar isso (ao incluir no <q> manifesto </q> do arquivo JAR um atributo
Library-Class especificando o principal nome da classe).)
</p>
<h2>Criar bibliotecas JAR</h2>
<p> O restante desta seção será dedicado a uma série de exemplos
bem comentados que ilustram como desenvolver bibliotecas do Logisim.
Você só deverá tentar fazer isso, se for um programador Java experiente.
Além desses exemplos, você irá encontrar documentação bastante escassa.
</p>
Você poderá baixar um arquivo JAR que lhe permitirá importar esses exemplos
do <i>website</i> do Logisim na seção Links. Esse arquivo JAR também conterá
o código-fonte desses exemplos.
</p>
<dl>
<dt> <a href="incr.html"> Incrementador em código de Gray</a> </dt>
<dd> <p> Ilustra os elementos essenciais de qualquer tipo de componente
por meio de um exemplo simples de um componente que tem uma entrada multibit
e calcula o valor do próximo código de Gray que o segue.
</p> </dd>
<dt> <a href="library.html"> Biblioteca de classes </a> </dt>
<dd> <p> Ilustra como definir uma biblioteca. Este é o ponto de entrada
para qualquer arquivo JAR - a classe cujo nome o usuário fornecerá quando
for carregar a biblioteca JAR.
</p> </dd>
<a <dt> href="simpctr.html"> Contador simples em código Gray </a> </dt>
<dd> <p> Ilustra como fazer um componente que tem estado interno;
em particular, um contador de 8 bits que itera em código de Gray.
</p> </dd>
<dt> <a href="counter.html"> Contador em código de Gray </a> </dt>
<dd> <p> Demonstra um componente completo, bem mais sofisticado, com o qual
o usuário poderá interagir. Ele implementa um contador em código de Gray, onde o
número de bits guardado é customizável, e onde o usuário poderá editar o valor
corrente, ao clicar nele com a ferramenta Testar e digitar um novo valor.
</p>
<a <dt> href="guide.html"> Orientações </a>
<dd> Informações gerais para as bibliotecas com desenvolvimento por terceiros. </p>
</dl>
<h2>License</h2>
<p>The code in this example JAR library is released under the MIT license,
a more permissive license than the GPL, under which the rest of Logisim is
released.</p>
<p>Copyright (c) 2009, Carl Burch.</p>
<p>Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:</p>
<p>The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.</p>
<p>THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.</p>
<p><strong>Próximo:</strong> <a href="incr.html">Incrementador em código de Gray</a>.</p>
</body>
</html>

128
doc/pt/html/guide/jar/library.html
View File

@ -1,64 +1,64 @@
<html>
<head>
<title>Classe Library</title>
</head>
<body bgcolor="FFFFFF">
<h1>Class Library</h1>
<p> O ponto de acesso para uma biblioteca JAR é uma classe derivada que estende a
classe original <code> Library </code>. O trabalho principal da biblioteca é
listar as ferramentas que estão disponíveis através da biblioteca, na maioria das vezes,
as ferramentas são todas aquelas necessárias para se adicionar os vários componentes
definidos - ou seja, instâncias da classe <code> AddTool </code> ao se trabalhar
com diferentes fábricas de componentes.
</p>
<h2>Components</h2>
<pre>
package com.cburch.gray;
import java.util.Arrays;
import java.util.List;
import com.cburch.logisim.tools.AddTool;
import com.cburch.logisim.tools.Library;
/** The library of components that the user can access. */
public class Components extends Library {
/** The list of all tools contained in this library. Technically,
* libraries contain tools, which is a slightly more general concept
* than components; practically speaking, though, you'll most often want
* to create AddTools for new components that can be added into the circuit.
*/
private List&lt;AddTool&gt; tools;
/** Constructs an instance of this library. This constructor is how
* Logisim accesses first when it opens the JAR file: It looks for
* a no-arguments constructor method of the user-designated class.
*/
public Components() {
tools = Arrays.asList(new AddTool[] {
new AddTool(new GrayIncrementer()),
new AddTool(new SimpleGrayCounter()),
new AddTool(new GrayCounter()),
});
}
/** Returns the name of the library that the user will see. */
public String getDisplayName() {
return "Gray Tools";
}
/** Returns a list of all the tools available in this library. */
public List&lt;AddTool&gt; getTools() {
return tools;
}
}
</pre>
<p><strong>Próximo:</strong> <a href="simpctr.html">Contador simples em código de Gray</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Classe Library</title>
</head>
<body bgcolor="FFFFFF">
<h1>Class Library</h1>
<p> O ponto de acesso para uma biblioteca JAR é uma classe derivada que estende a
classe original <code> Library </code>. O trabalho principal da biblioteca é
listar as ferramentas que estão disponíveis através da biblioteca, na maioria das vezes,
as ferramentas são todas aquelas necessárias para se adicionar os vários componentes
definidos - ou seja, instâncias da classe <code> AddTool </code> ao se trabalhar
com diferentes fábricas de componentes.
</p>
<h2>Components</h2>
<pre>
package com.cburch.gray;
import java.util.Arrays;
import java.util.List;
import com.cburch.logisim.tools.AddTool;
import com.cburch.logisim.tools.Library;
/** The library of components that the user can access. */
public class Components extends Library {
/** The list of all tools contained in this library. Technically,
* libraries contain tools, which is a slightly more general concept
* than components; practically speaking, though, you'll most often want
* to create AddTools for new components that can be added into the circuit.
*/
private List&lt;AddTool&gt; tools;
/** Constructs an instance of this library. This constructor is how
* Logisim accesses first when it opens the JAR file: It looks for
* a no-arguments constructor method of the user-designated class.
*/
public Components() {
tools = Arrays.asList(new AddTool[] {
new AddTool(new GrayIncrementer()),
new AddTool(new SimpleGrayCounter()),
new AddTool(new GrayCounter()),
});
}
/** Returns the name of the library that the user will see. */
public String getDisplayName() {
return "Gray Tools";
}
/** Returns a list of all the tools available in this library. */
public List&lt;AddTool&gt; getTools() {
return tools;
}
}
</pre>
<p><strong>Próximo:</strong> <a href="simpctr.html">Contador simples em código de Gray</a>.</p>
</body>
</html>

350
doc/pt/html/guide/jar/simpctr.html
View File

@ -1,175 +1,175 @@
<html>
<head>
<title>Contador simples em código de Gray</title>
</head>
<body bgcolor="FFFFFF">
<h1>Contador simples em código de Gray</h1>
<p> Muitas vezes queremos componentes que não são exclusivamente combinacionais
em sua natureza - ou seja, queremos que o componente tenha alguma memória.
Há uma sutileza importante na definição de tais componentes: você
não poderá ter o componente armazenando por si mesmo o estado, porque um
componente individual poderá aparecer várias vezes no mesmo circuito.
Ele poderá até não aparecer diretamente dentro de um circuito, mas
poderá ser contado mais de uma vez se existir em um subcircuito que
seja usado várias vezes.
</p>
<p> A solução será criar uma nova classe para representar o estado atual do objeto
e, associar instâncias a esse componente através do estado do circuito do qual
for herdado. Neste exemplo, que implementa um contador em código de Gray de 4 bits
sensível à borda, definimos uma classe <code> CounterData </code> para representar
o estado do contador, além da subclasse <code> InstanceFactory </code> como
ilustrado anteriormente.
Um objeto <code> CounterData </code> se lembrará tanto do valor atual do contador,
bem como da entrada de clock visto pela última vez (para detectar a borda de subida).
</p>
<h2>CounterData</h2>
<pre>
package com.cburch.gray;
import com.cburch.logisim.data.BitWidth;
import com.cburch.logisim.data.Value;
import com.cburch.logisim.instance.InstanceData;
import com.cburch.logisim.instance.InstanceState;
/** Represents the state of a counter. */
class CounterData implements InstanceData, Cloneable {
/** Retrieves the state associated with this counter in the circuit state,
* generating the state if necessary.
*/
public static CounterData get(InstanceState state, BitWidth width) {
CounterData ret = (CounterData) state.getData();
if(ret == null) {
// If it doesn't yet exist, then we'll set it up with our default
// values and put it into the circuit state so it can be retrieved
// in future propagations.
ret = new CounterData(null, Value.createKnown(width, 0));
state.setData(ret);
} else if(!ret.value.getBitWidth().equals(width)) {
ret.value = ret.value.extendWidth(width.getWidth(), Value.FALSE);
}
return ret;
}
/** The last clock input value observed. */
private Value lastClock;
/** The current value emitted by the counter. */
private Value value;
/** Constructs a state with the given values. */
public CounterData(Value lastClock, Value value) {
this.lastClock = lastClock;
this.value = value;
}
/** Returns a copy of this object. */
public Object clone() {
// We can just use what super.clone() returns: The only instance variables are
// Value objects, which are immutable, so we don't care that both the copy
// and the copied refer to the same Value objects. If we had mutable instance
// variables, then of course we would need to clone them.
try { return super.clone(); }
catch(CloneNotSupportedException e) { return null; }
}
/** Updates the last clock observed, returning true if triggered. */
public boolean updateClock(Value value) {
Value old = lastClock;
lastClock = value;
return old == Value.FALSE && value == Value.TRUE;
}
/** Returns the current value emitted by the counter. */
public Value getValue() {
return value;
}
/** Updates the current value emitted by the counter. */
public void setValue(Value value) {
this.value = value;
}
}
</pre>
<h2>SimpleCounter</h2>
<pre>
package com.cburch.gray;
import com.cburch.logisim.data.BitWidth;
import com.cburch.logisim.data.Bounds;
import com.cburch.logisim.data.Direction;
import com.cburch.logisim.instance.InstanceFactory;
import com.cburch.logisim.instance.InstancePainter;
import com.cburch.logisim.instance.InstanceState;
import com.cburch.logisim.instance.Port;
import com.cburch.logisim.util.GraphicsUtil;
import com.cburch.logisim.util.StringUtil;
/** Manufactures a simple counter that iterates over the 4-bit Gray Code. This
* example illustrates how a component can maintain its own internal state. All
* of the code relevant to state, though, appears in CounterData class. */
class SimpleGrayCounter extends InstanceFactory {
private static final BitWidth BIT_WIDTH = BitWidth.create(4);
// Again, notice how we don't have any instance variables related to an
// individual instance's state. We can't put that here, because only one
// SimpleGrayCounter object is ever created, and its job is to manage all
// instances that appear in any circuits.
public SimpleGrayCounter() {
super("Gray Counter (Simple)");
setOffsetBounds(Bounds.create(-30, -15, 30, 30));
setPorts(new Port[] {
new Port(-30, 0, Port.INPUT, 1),
new Port( 0, 0, Port.OUTPUT, BIT_WIDTH.getWidth()),
});
}
public void propagate(InstanceState state) {
// Here I retrieve the state associated with this component via a helper
// method. In this case, the state is in a CounterData object, which is
// also where the helper method is defined. This helper method will end
// up creating a CounterData object if one doesn't already exist.
CounterData cur = CounterData.get(state, BIT_WIDTH);
boolean trigger = cur.updateClock(state.getPort(0));
if(trigger) cur.setValue(GrayIncrementer.nextGray(cur.getValue()));
state.setPort(1, cur.getValue(), 9);
// (You might be tempted to determine the counter's current value
// via state.getPort(1). This is erroneous, though, because another
// component may be pushing a value onto the same point, which would
// "corrupt" the value found there. We really do need to store the
// current value in the instance.)
}
public void paintInstance(InstancePainter painter) {
painter.drawBounds();
painter.drawClock(0, Direction.EAST); // draw a triangle on port 0
painter.drawPort(1); // draw port 1 as just a dot
// Display the current counter value centered within the rectangle.
// However, if the context says not to show state (as when generating
// printer output), then skip this.
if(painter.getShowState()) {
CounterData state = CounterData.get(painter, BIT_WIDTH);
Bounds bds = painter.getBounds();
GraphicsUtil.drawCenteredText(painter.getGraphics(),
StringUtil.toHexString(BIT_WIDTH.getWidth(), state.getValue().toIntValue()),
bds.getX() + bds.getWidth() / 2,
bds.getY() + bds.getHeight() / 2);
}
}
}
</pre>
<p><strong>Próximo:</strong> <a href="counter.html">Contador em código de Gray</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Contador simples em código de Gray</title>
</head>
<body bgcolor="FFFFFF">
<h1>Contador simples em código de Gray</h1>
<p> Muitas vezes queremos componentes que não são exclusivamente combinacionais
em sua natureza - ou seja, queremos que o componente tenha alguma memória.
Há uma sutileza importante na definição de tais componentes: você
não poderá ter o componente armazenando por si mesmo o estado, porque um
componente individual poderá aparecer várias vezes no mesmo circuito.
Ele poderá até não aparecer diretamente dentro de um circuito, mas
poderá ser contado mais de uma vez se existir em um subcircuito que
seja usado várias vezes.
</p>
<p> A solução será criar uma nova classe para representar o estado atual do objeto
e, associar instâncias a esse componente através do estado do circuito do qual
for herdado. Neste exemplo, que implementa um contador em código de Gray de 4 bits
sensível à borda, definimos uma classe <code> CounterData </code> para representar
o estado do contador, além da subclasse <code> InstanceFactory </code> como
ilustrado anteriormente.
Um objeto <code> CounterData </code> se lembrará tanto do valor atual do contador,
bem como da entrada de clock visto pela última vez (para detectar a borda de subida).
</p>
<h2>CounterData</h2>
<pre>
package com.cburch.gray;
import com.cburch.logisim.data.BitWidth;
import com.cburch.logisim.data.Value;
import com.cburch.logisim.instance.InstanceData;
import com.cburch.logisim.instance.InstanceState;
/** Represents the state of a counter. */
class CounterData implements InstanceData, Cloneable {
/** Retrieves the state associated with this counter in the circuit state,
* generating the state if necessary.
*/
public static CounterData get(InstanceState state, BitWidth width) {
CounterData ret = (CounterData) state.getData();
if(ret == null) {
// If it doesn't yet exist, then we'll set it up with our default
// values and put it into the circuit state so it can be retrieved
// in future propagations.
ret = new CounterData(null, Value.createKnown(width, 0));
state.setData(ret);
} else if(!ret.value.getBitWidth().equals(width)) {
ret.value = ret.value.extendWidth(width.getWidth(), Value.FALSE);
}
return ret;
}
/** The last clock input value observed. */
private Value lastClock;
/** The current value emitted by the counter. */
private Value value;
/** Constructs a state with the given values. */
public CounterData(Value lastClock, Value value) {
this.lastClock = lastClock;
this.value = value;
}
/** Returns a copy of this object. */
public Object clone() {
// We can just use what super.clone() returns: The only instance variables are
// Value objects, which are immutable, so we don't care that both the copy
// and the copied refer to the same Value objects. If we had mutable instance
// variables, then of course we would need to clone them.
try { return super.clone(); }
catch(CloneNotSupportedException e) { return null; }
}
/** Updates the last clock observed, returning true if triggered. */
public boolean updateClock(Value value) {
Value old = lastClock;
lastClock = value;
return old == Value.FALSE && value == Value.TRUE;
}
/** Returns the current value emitted by the counter. */
public Value getValue() {
return value;
}
/** Updates the current value emitted by the counter. */
public void setValue(Value value) {
this.value = value;
}
}
</pre>
<h2>SimpleCounter</h2>
<pre>
package com.cburch.gray;
import com.cburch.logisim.data.BitWidth;
import com.cburch.logisim.data.Bounds;
import com.cburch.logisim.data.Direction;
import com.cburch.logisim.instance.InstanceFactory;
import com.cburch.logisim.instance.InstancePainter;
import com.cburch.logisim.instance.InstanceState;
import com.cburch.logisim.instance.Port;
import com.cburch.logisim.util.GraphicsUtil;
import com.cburch.logisim.util.StringUtil;
/** Manufactures a simple counter that iterates over the 4-bit Gray Code. This
* example illustrates how a component can maintain its own internal state. All
* of the code relevant to state, though, appears in CounterData class. */
class SimpleGrayCounter extends InstanceFactory {
private static final BitWidth BIT_WIDTH = BitWidth.create(4);
// Again, notice how we don't have any instance variables related to an
// individual instance's state. We can't put that here, because only one
// SimpleGrayCounter object is ever created, and its job is to manage all
// instances that appear in any circuits.
public SimpleGrayCounter() {
super("Gray Counter (Simple)");
setOffsetBounds(Bounds.create(-30, -15, 30, 30));
setPorts(new Port[] {
new Port(-30, 0, Port.INPUT, 1),
new Port( 0, 0, Port.OUTPUT, BIT_WIDTH.getWidth()),
});
}
public void propagate(InstanceState state) {
// Here I retrieve the state associated with this component via a helper
// method. In this case, the state is in a CounterData object, which is
// also where the helper method is defined. This helper method will end
// up creating a CounterData object if one doesn't already exist.
CounterData cur = CounterData.get(state, BIT_WIDTH);
boolean trigger = cur.updateClock(state.getPort(0));
if(trigger) cur.setValue(GrayIncrementer.nextGray(cur.getValue()));
state.setPort(1, cur.getValue(), 9);
// (You might be tempted to determine the counter's current value
// via state.getPort(1). This is erroneous, though, because another
// component may be pushing a value onto the same point, which would
// "corrupt" the value found there. We really do need to store the
// current value in the instance.)
}
public void paintInstance(InstancePainter painter) {
painter.drawBounds();
painter.drawClock(0, Direction.EAST); // draw a triangle on port 0
painter.drawPort(1); // draw port 1 as just a dot
// Display the current counter value centered within the rectangle.
// However, if the context says not to show state (as when generating
// printer output), then skip this.
if(painter.getShowState()) {
CounterData state = CounterData.get(painter, BIT_WIDTH);
Bounds bds = painter.getBounds();
GraphicsUtil.drawCenteredText(painter.getGraphics(),
StringUtil.toHexString(BIT_WIDTH.getWidth(), state.getValue().toIntValue()),
bds.getX() + bds.getWidth() / 2,
bds.getY() + bds.getHeight() / 2);
}
}
}
</pre>
<p><strong>Próximo:</strong> <a href="counter.html">Contador em código de Gray</a>.</p>
</body>
</html>

114
doc/pt/html/guide/log/file.html
View File

@ -1,57 +1,57 @@
<html>
<head>
<title>A guia Arquivos (File)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Arquivos (File)</h1>
<p> A guia Arquivo (File) permitirá que você especifique onde o registro deverá
ser colocado.
</p>
<center> <img src="file.png" width="460" height="389"> </center>
<p> Na parte superior há um indicador se existir registro em andamento e
um botão para ativá-lo ou desativá-lo. (Note que você não poderá habilitá-lo
até que um arquivo seja selecionado mais abaixo.) Um botão lhe permitirá
suspender e reiniciar gravações no arquivo. Quando você escolher a janela do projeto
para a visualização outra simulação, o arquivo de registros irá parar automaticamente
e, se você retornar ao original, e quiser continuar a registrar, você precisará
reativar a gravação manualmente utilizando o botão na parte superior.
</p>
<p> No meio, há um indicador do que está sendo gravado no arquivo. Para
alterá-lo, deve-se usar o botão Selecionar (Select). Ao fazer isso, a gravação
será iniciada automaticamente. Se você selecionar um arquivo pré-existente, o Logisim
perguntará se você deseja substituir o arquivo ou acrescentar novos
registros ao seu final.
</p>
<p> Na parte inferior você poderá controlar se uma linha de cabeçalho deverá
ser colocada no arquivo para indicar quais itens estarão na seleção. Se linhas de
cabeçalho forem adicionadas, então, uma nova linha de cabeçalho também será colocada
no arquivo sempre que a seleção for alterada.
</p>
<h2> Formato de arquivo </h2>
<p> As entradas serão colocadas no arquivo em formato delimitado por tabulações
correspondentes o mais próximo possível do que aparecer sob a guia Tabela. (Uma
diferença é que todas as linhas de cabeçalho irão fornecer o caminho completo
para os componentes em subcircuitos.) O formato é intencionalmente simples,
de modo que você poderá submetê-lo a outro programa para ser processado, como um
<i>script</i> Python/Perl ou um gerenciador de planilhas.
</p>
<p> Assim um <i>script</i> poderá processar o arquivo, ao mesmo tempo em que o Logisim
estiver em execução, liberando novos registros para o disco a cada
500 ms. Note-se que Logisim também poderá fechar intermitentemente e depois
reabrir o arquivo durante a simulação, especialmente se alguns segundos
decorrerem sem que qualquer novo registro tenha sido adicionado.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html"><em>Guia do usuário</em></a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia Arquivos (File)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Arquivos (File)</h1>
<p> A guia Arquivo (File) permitirá que você especifique onde o registro deverá
ser colocado.
</p>
<center> <img src="file.png" width="460" height="389"> </center>
<p> Na parte superior há um indicador se existir registro em andamento e
um botão para ativá-lo ou desativá-lo. (Note que você não poderá habilitá-lo
até que um arquivo seja selecionado mais abaixo.) Um botão lhe permitirá
suspender e reiniciar gravações no arquivo. Quando você escolher a janela do projeto
para a visualização outra simulação, o arquivo de registros irá parar automaticamente
e, se você retornar ao original, e quiser continuar a registrar, você precisará
reativar a gravação manualmente utilizando o botão na parte superior.
</p>
<p> No meio, há um indicador do que está sendo gravado no arquivo. Para
alterá-lo, deve-se usar o botão Selecionar (Select). Ao fazer isso, a gravação
será iniciada automaticamente. Se você selecionar um arquivo pré-existente, o Logisim
perguntará se você deseja substituir o arquivo ou acrescentar novos
registros ao seu final.
</p>
<p> Na parte inferior você poderá controlar se uma linha de cabeçalho deverá
ser colocada no arquivo para indicar quais itens estarão na seleção. Se linhas de
cabeçalho forem adicionadas, então, uma nova linha de cabeçalho também será colocada
no arquivo sempre que a seleção for alterada.
</p>
<h2> Formato de arquivo </h2>
<p> As entradas serão colocadas no arquivo em formato delimitado por tabulações
correspondentes o mais próximo possível do que aparecer sob a guia Tabela. (Uma
diferença é que todas as linhas de cabeçalho irão fornecer o caminho completo
para os componentes em subcircuitos.) O formato é intencionalmente simples,
de modo que você poderá submetê-lo a outro programa para ser processado, como um
<i>script</i> Python/Perl ou um gerenciador de planilhas.
</p>
<p> Assim um <i>script</i> poderá processar o arquivo, ao mesmo tempo em que o Logisim
estiver em execução, liberando novos registros para o disco a cada
500 ms. Note-se que Logisim também poderá fechar intermitentemente e depois
reabrir o arquivo durante a simulação, especialmente se alguns segundos
decorrerem sem que qualquer novo registro tenha sido adicionado.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html"><em>Guia do usuário</em></a></em>.</p>
</body>
</html>

112
doc/pt/html/guide/log/index.html
View File

@ -1,56 +1,56 @@
<html>
<head>
<title>Registro</title>
</head>
<body bgcolor="FFFFFF">
<h1>Registro</h1>
<p> Ao testar um circuito maior, e para documentar seu comportamento,
um registro poderá ser guardado. Essa é a finalidade do módulo de registro do Logisim,
que lhe permitirá selecionar os componentes cujos valores deverão ser registrados,
opcionalmente, você poderá especificar um arquivo onde o registro deverá ser colocado.
</p>
<strong> Nota: </strong> O módulo de registro está em fase <i>alfa</i>, e poderá
apresentar defeitos, bem como estar sujeito a alterações significativas no futuro.
Enquanto relatórios de <i>bugs</i> e sugestões são bem-vindos para todos os casos,
eles serão particularmente bem-vindos a respeito desse recurso relativamente novo.
Se você não enviar comentários, então ele provavelmente não sofrerá alterações.
</p>
<p> Você poderá entrar no módulo através da opção Registro (Logging)...
no menu Simular (Simulate). Ela abrirá uma janela com três guias.
</p>
<center> <img src="selection.png" width="460" height="389"> </center>
<p>
Vamos discutir cada uma dessas guias separadamente.
</p>
<blockquote>
<a href="selection.html"> A guia Seleção </a>
<br> <a href="table.html"> A guia Tabela </a>
<br> <a href="file.html"> A guia Arquivo </a>
</blockquote>
</p>
<p> Cada projeto tem apenas uma janela de registro; quando você alternar
para a visualização de outro circuito dentro do projeto, haverá troca de janelas,
e automaticamente o foco irá mudar para o outro circuito. Ou seja, ele fará
isso a menos que você esteja <a href="../subcirc/debug.html"> movendo para cima ou
para baixo dentro da mesma simulação </a>, caso em que o módulo de registro não
irá se alterar.
</p>
<p> Observe que, quando as opções de módulo de registro mudarem para outra
simulação, ela deixará de gravar qualquer registro em arquivo. Se você alternar
de volta para a simulação novamente, ele irá se lembrar da configuração para
a simulação anterior, mas você terá que reativar o registro manualmente.
</p>
<p><strong>Próximo:</strong> <a href="selection.html">A guia Seleção (Selection)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Registro</title>
</head>
<body bgcolor="FFFFFF">
<h1>Registro</h1>
<p> Ao testar um circuito maior, e para documentar seu comportamento,
um registro poderá ser guardado. Essa é a finalidade do módulo de registro do Logisim,
que lhe permitirá selecionar os componentes cujos valores deverão ser registrados,
opcionalmente, você poderá especificar um arquivo onde o registro deverá ser colocado.
</p>
<strong> Nota: </strong> O módulo de registro está em fase <i>alfa</i>, e poderá
apresentar defeitos, bem como estar sujeito a alterações significativas no futuro.
Enquanto relatórios de <i>bugs</i> e sugestões são bem-vindos para todos os casos,
eles serão particularmente bem-vindos a respeito desse recurso relativamente novo.
Se você não enviar comentários, então ele provavelmente não sofrerá alterações.
</p>
<p> Você poderá entrar no módulo através da opção Registro (Logging)...
no menu Simular (Simulate). Ela abrirá uma janela com três guias.
</p>
<center> <img src="selection.png" width="460" height="389"> </center>
<p>
Vamos discutir cada uma dessas guias separadamente.
</p>
<blockquote>
<a href="selection.html"> A guia Seleção </a>
<br> <a href="table.html"> A guia Tabela </a>
<br> <a href="file.html"> A guia Arquivo </a>
</blockquote>
</p>
<p> Cada projeto tem apenas uma janela de registro; quando você alternar
para a visualização de outro circuito dentro do projeto, haverá troca de janelas,
e automaticamente o foco irá mudar para o outro circuito. Ou seja, ele fará
isso a menos que você esteja <a href="../subcirc/debug.html"> movendo para cima ou
para baixo dentro da mesma simulação </a>, caso em que o módulo de registro não
irá se alterar.
</p>
<p> Observe que, quando as opções de módulo de registro mudarem para outra
simulação, ela deixará de gravar qualquer registro em arquivo. Se você alternar
de volta para a simulação novamente, ele irá se lembrar da configuração para
a simulação anterior, mas você terá que reativar o registro manualmente.
</p>
<p><strong>Próximo:</strong> <a href="selection.html">A guia Seleção (Selection)</a>.</p>
</body>
</html>

128
doc/pt/html/guide/log/selection.html
View File

@ -1,64 +1,64 @@
<html>
<head>
<title>A guia Seleção (Selection)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Seleção (Selection)</h1>
<p> A guia Seleção permite selecionar que valores deverão ser incluídos no registro.
A janela abaixo corresponde ao seguinte circuito.
</p>
<center> <img src="counter.png" width="233" height="128"> <br>
<p></p>
<img src="selection.png" width="460" height="389"> </center>
<p> A guia está dividida em três áreas verticais. A primeira (mais à esquerda) é
uma lista de todos os componentes no circuito cujos valores poderão ser registrados.
Entre as bibliotecas predefinidas, os seguintes tipos de componentes têm suporte
para registro:
</p>
<blockquote>
Biblioteca Base: componentes Pino (Pin), Sonda (Probe), e Clock <br>
Biblioteca E/S: componentes Botão (Button) e LED <br>
Biblioteca Memória: todos os componentes, exceto ROM
</blockquote>
Para os componentes que tenham rótulos a eles associados, seus nomes corresponderão
a esses rótulos; outros nomes poderão especificar seu tipo e sua localização dentro
do circuito.
Quaisquer subcircuitos que aparecerem na lista, não poderão ser selecionados
para registro, mas os componentes elegíveis dentro deles poderão ser.
Observar que o componente RAM exige a escolha de quais endereços da memória deverão
ser registrados, mas lhe permitirá registrar apenas os 256 primeiros endereços.
</p>
<p> A última área vertical (à direita) enumera os componentes que foram selecionados.
Além disso, indicará em que base os valores do componente multibit serão registrados,
a base não tem um efeito significativo sobre valores de um bit só.
</p>
<p> A coluna do meio permitirá a manipulação dos itens dentro da seleção.
<ul>
<li> <strong> Adicionar </strong> acrescentará um ou mais itens escolhidos à esquerda
na seleção.
<li> <strong> Alterar Base </strong> mudará a base atual para componente selecionado
entre 2 (binário), 10 (decimal), e 16 (hexadecimal).
<li> <strong> Mover para cima </strong> deslocará o componente que estiver selecionado
para a cima uma posição.
<li> <strong> Mover para baixo </strong> deslocará o componente que estiver selecionado
para baixo uma posição.
<li> <strong> Remover </strong> apagará o componente que estiver selecionado.
</ul></p>
<p><strong>Próximo:</strong> <a href="table.html">A guia Tabela (Table)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia Seleção (Selection)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Seleção (Selection)</h1>
<p> A guia Seleção permite selecionar que valores deverão ser incluídos no registro.
A janela abaixo corresponde ao seguinte circuito.
</p>
<center> <img src="counter.png" width="233" height="128"> <br>
<p></p>
<img src="selection.png" width="460" height="389"> </center>
<p> A guia está dividida em três áreas verticais. A primeira (mais à esquerda) é
uma lista de todos os componentes no circuito cujos valores poderão ser registrados.
Entre as bibliotecas predefinidas, os seguintes tipos de componentes têm suporte
para registro:
</p>
<blockquote>
Biblioteca Base: componentes Pino (Pin), Sonda (Probe), e Clock <br>
Biblioteca E/S: componentes Botão (Button) e LED <br>
Biblioteca Memória: todos os componentes, exceto ROM
</blockquote>
Para os componentes que tenham rótulos a eles associados, seus nomes corresponderão
a esses rótulos; outros nomes poderão especificar seu tipo e sua localização dentro
do circuito.
Quaisquer subcircuitos que aparecerem na lista, não poderão ser selecionados
para registro, mas os componentes elegíveis dentro deles poderão ser.
Observar que o componente RAM exige a escolha de quais endereços da memória deverão
ser registrados, mas lhe permitirá registrar apenas os 256 primeiros endereços.
</p>
<p> A última área vertical (à direita) enumera os componentes que foram selecionados.
Além disso, indicará em que base os valores do componente multibit serão registrados,
a base não tem um efeito significativo sobre valores de um bit só.
</p>
<p> A coluna do meio permitirá a manipulação dos itens dentro da seleção.
<ul>
<li> <strong> Adicionar </strong> acrescentará um ou mais itens escolhidos à esquerda
na seleção.
<li> <strong> Alterar Base </strong> mudará a base atual para componente selecionado
entre 2 (binário), 10 (decimal), e 16 (hexadecimal).
<li> <strong> Mover para cima </strong> deslocará o componente que estiver selecionado
para a cima uma posição.
<li> <strong> Mover para baixo </strong> deslocará o componente que estiver selecionado
para baixo uma posição.
<li> <strong> Remover </strong> apagará o componente que estiver selecionado.
</ul></p>
<p><strong>Próximo:</strong> <a href="table.html">A guia Tabela (Table)</a>.</p>
</body>
</html>

56
doc/pt/html/guide/log/table.html
View File

@ -1,28 +1,28 @@
<html>
<head>
<title>A guia Tabela (Table)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Tabela (Table)</h1>
<p> A guia Tabela exibe o registro atual graficamente. </p>
<center> <img src="table.png" width="460" height="389"> </center>
<p> A tabela contém uma coluna para cada componente na seleção.
Cada linha da tabela apresenta um instantâneo da simulação após
as propagações de valores terem sido concluídas.
As linhas duplicadas não serão adicionadas ao registro.
Notar que apenas as 400 linhas mais recentes serão exibidas.
Algumas linhas poderão ter entradas vazias, se o componente
que lhes corresponder não estiver na seleção no momento
em que a linha for computada.
</p>
<p> O quadro apresentado é apenas para ilustração. Ele não é interativo. </p>
<p><strong>Próximo:</strong> <a href="file.html">A guia Arquivo (File)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia Tabela (Table)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Tabela (Table)</h1>
<p> A guia Tabela exibe o registro atual graficamente. </p>
<center> <img src="table.png" width="460" height="389"> </center>
<p> A tabela contém uma coluna para cada componente na seleção.
Cada linha da tabela apresenta um instantâneo da simulação após
as propagações de valores terem sido concluídas.
As linhas duplicadas não serão adicionadas ao registro.
Notar que apenas as 400 linhas mais recentes serão exibidas.
Algumas linhas poderão ter entradas vazias, se o componente
que lhes corresponder não estiver na seleção no momento
em que a linha for computada.
</p>
<p> O quadro apresentado é apenas para ilustração. Ele não é interativo. </p>
<p><strong>Próximo:</strong> <a href="file.html">A guia Arquivo (File)</a>.</p>
</body>
</html>

86
doc/pt/html/guide/mem/hex.html
View File

@ -1,43 +1,43 @@
<html>
<head>
<title>Editor hexadecimal</title>
</head>
<body bgcolor="FFFFFF">
<h1>Editor hexadecimal</h1>
<p> O Logisim inclui um editor hexadecimal integrado para visualizar e editar
o conteúdo da memória. Para acessá-lo, basta abrir um menu <i>pop-up</i> para
o componente de memória e selecionar Editar conteúdo...
Para componentes ROM, cujo conteúdo de memória faz parte do
valor do atributo, você também poderá acessar o editor hexadecimal ao clicar
o valor do atributo correspondente.
</p>
<center> <img src="hex.png" width="317" height="162"> </center>
<p> Os números em itálico à esquerda mostram endereços de memória,
escritos em hexadecimal. Os outros números exibem valores
a partir desse endereço de memória, o editor hexadecimal poderá exibir
quatro, oito ou dezesseis valores por linha, dependendo do que couber
na janela. Para ajudar a contar, cada grupo de quatro valores
terá um espaço maior entre eles.
</p>
<p> Você poderá navegar através de memória usando a barra de rolagem, ou
usando o teclado (as teclas de setas, home, end, page up e
página para baixo). Escrever caracteres hexadecimais alterará o
valor selecionado.
</p>
<p> Você poderá selecionar um intervalo de valores, arrastando o mouse,
com <i>shift-click</i> do mouse, ou navegando através de memória com
o teclado, enquanto pressionar a tecla <i>shift</i>. Os valores poderão ser
copiados e colados usando o menu Editar; a área de transferência também poderá ser
usada em outras aplicações.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html"><em>Guia do usuário</em></a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Editor hexadecimal</title>
</head>
<body bgcolor="FFFFFF">
<h1>Editor hexadecimal</h1>
<p> O Logisim inclui um editor hexadecimal integrado para visualizar e editar
o conteúdo da memória. Para acessá-lo, basta abrir um menu <i>pop-up</i> para
o componente de memória e selecionar Editar conteúdo...
Para componentes ROM, cujo conteúdo de memória faz parte do
valor do atributo, você também poderá acessar o editor hexadecimal ao clicar
o valor do atributo correspondente.
</p>
<center> <img src="hex.png" width="317" height="162"> </center>
<p> Os números em itálico à esquerda mostram endereços de memória,
escritos em hexadecimal. Os outros números exibem valores
a partir desse endereço de memória, o editor hexadecimal poderá exibir
quatro, oito ou dezesseis valores por linha, dependendo do que couber
na janela. Para ajudar a contar, cada grupo de quatro valores
terá um espaço maior entre eles.
</p>
<p> Você poderá navegar através de memória usando a barra de rolagem, ou
usando o teclado (as teclas de setas, home, end, page up e
página para baixo). Escrever caracteres hexadecimais alterará o
valor selecionado.
</p>
<p> Você poderá selecionar um intervalo de valores, arrastando o mouse,
com <i>shift-click</i> do mouse, ou navegando através de memória com
o teclado, enquanto pressionar a tecla <i>shift</i>. Os valores poderão ser
copiados e colados usando o menu Editar; a área de transferência também poderá ser
usada em outras aplicações.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html"><em>Guia do usuário</em></a></em>.</p>
</body>
</html>

60
doc/pt/html/guide/mem/index.html
View File

@ -1,30 +1,30 @@
<html>
<head>
<title> Componentes de memória </title>
</head>
bgcolor="FFFFFF"> <body
<h1> Componentes de memória </h1>
<p> Os componentes RAM e ROM são dois dos tipos mais úteis de
componentes nas bibliotecas predefinidas no Logisim. No entanto, devido ao
volume de informações que poderão armazenar, eles serão também dois
dos componentes mais complexos.
</p>
<p> A documentação sobre como eles funcionam dentro de um circuito poderá
ser encontrada em <a href="../../libs/mem/ram.html"> RAM </a> e
<a href="../../libs/mem/rom.html"> ROM </a> páginas de
<em> Biblioteca de Referência </em>. Esta seção do <em> Guia do usuário </em>
explicará a interface que lhe permitirá visualizar e editar o conteúdo da memória.
</p>
<blockquote> <a href="poke.html"> Testar memória </a>
<br> <a href="menu.html"> Menus <i>pop-up</i> e arquivos </a>
<br> <a href="hex.html"> Editor hexadecimal integrado do Logisim </a>
</blockquote>
<p><strong>Próximo:</strong> <a href="poke.html">Testar memória</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title> Componentes de memória </title>
</head>
bgcolor="FFFFFF"> <body
<h1> Componentes de memória </h1>
<p> Os componentes RAM e ROM são dois dos tipos mais úteis de
componentes nas bibliotecas predefinidas no Logisim. No entanto, devido ao
volume de informações que poderão armazenar, eles serão também dois
dos componentes mais complexos.
</p>
<p> A documentação sobre como eles funcionam dentro de um circuito poderá
ser encontrada em <a href="../../libs/mem/ram.html"> RAM </a> e
<a href="../../libs/mem/rom.html"> ROM </a> páginas de
<em> Biblioteca de Referência </em>. Esta seção do <em> Guia do usuário </em>
explicará a interface que lhe permitirá visualizar e editar o conteúdo da memória.
</p>
<blockquote> <a href="poke.html"> Testar memória </a>
<br> <a href="menu.html"> Menus <i>pop-up</i> e arquivos </a>
<br> <a href="hex.html"> Editor hexadecimal integrado do Logisim </a>
</blockquote>
<p><strong>Próximo:</strong> <a href="poke.html">Testar memória</a>.</p>
</body>
</html>

132
doc/pt/html/guide/mem/menu.html
View File

@ -1,66 +1,66 @@
<html>
<head>
<title>Menus <i>pop-up</i> e arquivos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Menus <i>pop-up</i> e arquivos</h1>
<p> O menu <i>pop-up</i> para a memória inclui quatro opções além
das opções comuns a todos os componentes: </p>
<ul>
<li> Editar conteúdo: Abrir um editor hexadecimal para editar o conteúdo
de memória.
</li>
<li> Limpar conteúdo: Redefinir todos os valores na memória como 0
</li>
<li> Carregar imagem...: Redefinir todos os valores na memória com base em valores
encontrados em um arquivo usando o formato descrito abaixo.
</li>
<li> Salvar imagem...: Armazenar todos os valores na memória em um arquivo usando
o formato descrito abaixo.
</li>
</ul>
<p> O formato de arquivo usado para arquivos de imagem é intencionalmente simples;
isso lhe permitirá escrever um programa, como um montador, que
gerará imagens de conteúdos que poderão ser carregados na memória.
Como exemplo desse formato de arquivo, se tivermos uma memória de 256-bytes cujos
cinco primeiros bytes de 2, 3, 0, 20, e -1, e todos os valores subsequentes
forem 0, a imagem em arquivo texto teria o seguinte conteúdo:
</p>
<blockquote><pre>
v2.0 raw
02
03
00
14
ff
</pre></blockquote>
<p> A primeira linha identifica o formato de arquivo usado (atualmente, só existe
um formato de arquivo reconhecido). Valores subsequentes listados em
hexadecimal, a partir de endereço 0. Você poderá colocar vários desses
em uma mesma linha. Se houver mais posições de memória que as identificadas
no arquivo, o Logisim irá carregar 0 nessas outras posições.
</p>
<p> O arquivo de imagem poderá usar codificação do tipo <i>run-length</i>. Por exemplo,
ao invés de listar o valor <tt> 00</tt> dezesseis vezes em sequência, o arquivo
poderá incluir <tt> 16*00</tt>. Alerto que o número de repetições é escrito em base 10.
Arquivos produzidos pelo Logisim usarão essa codificação para todos os casos com
pelo menos quatro valores.
</p>
<p> Você poderá colocar comentários no arquivo usando o símbolo '#'. Todos os caracteres
na linha a partir do símbolo "#" serão ignorado pelo Logisim.
</p>
<p><strong>Próximo:</strong> <a href="hex.html">Editor hexadecimal</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Menus <i>pop-up</i> e arquivos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Menus <i>pop-up</i> e arquivos</h1>
<p> O menu <i>pop-up</i> para a memória inclui quatro opções além
das opções comuns a todos os componentes: </p>
<ul>
<li> Editar conteúdo: Abrir um editor hexadecimal para editar o conteúdo
de memória.
</li>
<li> Limpar conteúdo: Redefinir todos os valores na memória como 0
</li>
<li> Carregar imagem...: Redefinir todos os valores na memória com base em valores
encontrados em um arquivo usando o formato descrito abaixo.
</li>
<li> Salvar imagem...: Armazenar todos os valores na memória em um arquivo usando
o formato descrito abaixo.
</li>
</ul>
<p> O formato de arquivo usado para arquivos de imagem é intencionalmente simples;
isso lhe permitirá escrever um programa, como um montador, que
gerará imagens de conteúdos que poderão ser carregados na memória.
Como exemplo desse formato de arquivo, se tivermos uma memória de 256-bytes cujos
cinco primeiros bytes de 2, 3, 0, 20, e -1, e todos os valores subsequentes
forem 0, a imagem em arquivo texto teria o seguinte conteúdo:
</p>
<blockquote><pre>
v2.0 raw
02
03
00
14
ff
</pre></blockquote>
<p> A primeira linha identifica o formato de arquivo usado (atualmente, só existe
um formato de arquivo reconhecido). Valores subsequentes listados em
hexadecimal, a partir de endereço 0. Você poderá colocar vários desses
em uma mesma linha. Se houver mais posições de memória que as identificadas
no arquivo, o Logisim irá carregar 0 nessas outras posições.
</p>
<p> O arquivo de imagem poderá usar codificação do tipo <i>run-length</i>. Por exemplo,
ao invés de listar o valor <tt> 00</tt> dezesseis vezes em sequência, o arquivo
poderá incluir <tt> 16*00</tt>. Alerto que o número de repetições é escrito em base 10.
Arquivos produzidos pelo Logisim usarão essa codificação para todos os casos com
pelo menos quatro valores.
</p>
<p> Você poderá colocar comentários no arquivo usando o símbolo '#'. Todos os caracteres
na linha a partir do símbolo "#" serão ignorado pelo Logisim.
</p>
<p><strong>Próximo:</strong> <a href="hex.html">Editor hexadecimal</a>.</p>
</body>
</html>

126
doc/pt/html/guide/mem/poke.html
View File

@ -1,63 +1,63 @@
<html>
<head>
<title>Testar memória</title>
</head>
<body bgcolor="FFFFFF">
<h1>Testar memória</h1>
<p> Você poderá manipular o conteúdo da memória usando a ferramenta Testar (Poke),
mas a interface para isso é severamente limitada por restrições de espaço:
Por mais que a simples edição, você provavelmente irá
<a href="hex.html"> achar o editor hexadecimal integrado </a> muito mais
conveniente.
</p>
<p> No entanto, para visualizar e editar os valores dentro do circuito,
a ferramenta Testar (Poke) tem dois modos de operação:
você poderá editar o endereço exibido, e também poderá editar um valor individual.
</p>
<p> Para editar o endereço exibido, clicar fora do retângulo mostrado.
O Logisim irá desenhar um retângulo vermelho em torno do endereço.
</p>
<ul>
<li> <p> Se entrar com dígitos hexadecimais irá mudar o endereço de acordo.
</p> </li>
<li> <p> Se digitar a tecla Enter irá rolar para baixo uma linha.
</p> </li>
<li> <p> Se digitar a tecla Backspace irá rolar uma linha para cima.
</p> </li>
<li> <p> Se digitar a barra de espaço irá rolar uma página (quatro linhas).
</p> </li>
</ul>
<p> Para editar determinado conteúdo, clicar no valor dentro do
retângulo mostrado. Logisim irá desenhar um retângulo vermelho em torno desse endereço.
<ul>
<li> <p> Se entrar com dígitos hexadecimais irá mudar o valor do endereço atual de acordo.
</p> </li>
<li> <p> Se apertar a tecla Enter irá editar o valor mostrado logo abaixo
(uma linha para baixo).
</p> </li>
<li> <p> Se apertar a tecla Backspace irá editar o valor na endereço anterior.
</p> </li>
<li> <p> Se apertar a barra de espaço irá editar o valor no endereço seguinte.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <a href="menu.html">Menus <i>pop-up</i> menus e arquivos</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Testar memória</title>
</head>
<body bgcolor="FFFFFF">
<h1>Testar memória</h1>
<p> Você poderá manipular o conteúdo da memória usando a ferramenta Testar (Poke),
mas a interface para isso é severamente limitada por restrições de espaço:
Por mais que a simples edição, você provavelmente irá
<a href="hex.html"> achar o editor hexadecimal integrado </a> muito mais
conveniente.
</p>
<p> No entanto, para visualizar e editar os valores dentro do circuito,
a ferramenta Testar (Poke) tem dois modos de operação:
você poderá editar o endereço exibido, e também poderá editar um valor individual.
</p>
<p> Para editar o endereço exibido, clicar fora do retângulo mostrado.
O Logisim irá desenhar um retângulo vermelho em torno do endereço.
</p>
<ul>
<li> <p> Se entrar com dígitos hexadecimais irá mudar o endereço de acordo.
</p> </li>
<li> <p> Se digitar a tecla Enter irá rolar para baixo uma linha.
</p> </li>
<li> <p> Se digitar a tecla Backspace irá rolar uma linha para cima.
</p> </li>
<li> <p> Se digitar a barra de espaço irá rolar uma página (quatro linhas).
</p> </li>
</ul>
<p> Para editar determinado conteúdo, clicar no valor dentro do
retângulo mostrado. Logisim irá desenhar um retângulo vermelho em torno desse endereço.
<ul>
<li> <p> Se entrar com dígitos hexadecimais irá mudar o valor do endereço atual de acordo.
</p> </li>
<li> <p> Se apertar a tecla Enter irá editar o valor mostrado logo abaixo
(uma linha para baixo).
</p> </li>
<li> <p> Se apertar a tecla Backspace irá editar o valor na endereço anterior.
</p> </li>
<li> <p> Se apertar a barra de espaço irá editar o valor no endereço seguinte.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <a href="menu.html">Menus <i>pop-up</i> menus e arquivos</a>.</p>
</body>
</html>

252
doc/pt/html/guide/menu/edit.html
View File

@ -1,126 +1,126 @@
<html>
<head>
<title>O menu Editar</title>
</head>
<body bgcolor="FFFFFF">
<h1>O menu Editar</h1>
<dl>
<dt> <strong> Desfazer <em> XX </em> </strong> </dt>
<dd> <p> Desfazer a ação executada mais recentemente que afetará a forma como o
circuito será salvo em arquivo. Notar que isso não incluirá mudanças no estado
do circuito (como acontece com as manipulações executadas pela ferramenta Testar (Poke).
</p> </dd>
<dt> <strong> Recortar </strong> </dt>
<dd> <p> Remover os componentes atualmente selecionados a partir do circuito para a
área de transferência do Logisim.
</p>
<strong> Nota: </strong> A área da transferência do Logisim é mantida em separado
da área que serve o sistema global; como resultado, recortar, copiar e
colar não irão funcionar em diferentes aplicações, incluindo até mesmo outras
que estejam executando cópias do Logisim. Se, no entanto, você tiver outros
projetos abertos no âmbito do mesmo processo Logisim, então você será
capaz de copiar, recortar e colar entre eles.
</p> </dd>
<dt> <strong> Copiar </strong> </dt>
<dd> <p> Copiar os componentes selecionados atualmente no circuito para
área de transferência do Logisim.
<br>(Ver nota do menu Recortar acima.)
</p> </dd>
<dt> <strong> Colar </strong> </dt>
<dd> <p> Colar os componentes da área de transferência do Logisim segundo
a seleção atual.
<br>(Ver nota no item do menu Recortar).
</p>
<p> Quando você colar os componentes, isso não será imediatamente realizado,
em vez disso, eles serão desenhados em cinza claro. Eles, na verdade,
não serão "efetivados" no circuito até que você mova a seleção, ou
a altere para que os componentes não estejam mais nela.
</p>
<p> A razão para esse comportamento estranho é o seguinte: para ser coerente com
seu próprio comportamento, o Logisim deverá imediatamente mesclar quaisquer conexões
tão logo sejam inseridas em um circuito; isso mudaria processo de fusão das
conexões já existentes. Quando você colar as conexões transferidas, no entanto,
você poderá colocá-las em um local diferente, e evitar a mudança inerente ao processo
de fusão que for contra a sua vontade.
</p> </dd>
<dt> <strong> Excluir </strong> </dt>
<dd> <p> Remover todos os componentes da seleção atual do circuito,
sem modificar a área de transferência.
</p> </dd>
<dt> <strong> Duplicar </strong> </dt>
<dd> <p> Criar uma cópia de todos os componentes na seleção atual. Isso é como
selecionar, copiar e colar, exceto que a duplicação não irá modificar ou usar
a área de transferência.
</p> </dd>
<dt> <strong> Selecionar tudo </strong> </dt>
<dd> <p> Selecionar todos os componentes do circuito.
</p> </dd>
<dt> <strong> Elevar a seleção </strong> </dt>
<p> <dd> Disponível somente durante a edição como deve ser a aparência de um circuito,
esse item de menu elevará o(s) objeto(s) selecionado(s) a ser(em) desenhado(s)
sobre outro quando houver sobreposições. Se o objeto selecionado for sobreposto por
outros, ele será elevado apenas sobre o que estiver mais por baixo;
selecionar o item de menu repetidamente até ficar na ordem que desejar.
</p>
<p> (Determinar se dois objetos arbitrários se sobrepõem é difícil. O Logisim usa
um algoritmo de seleção de vários pontos aleatórios em cada um dos dois objetos,
e verifica se algum ponto pertence também ao outro objeto. Às vezes, ele poderá
deixar de detectar alguma sobreposição se essa for pequena - digamos, menos de 5% de
um dos objetos.)
</p> </dd>
<dt> <strong> Baixar a seleção </strong> </dt>
<p> <dd> Disponível apenas ao editar a aparência de um circuito, esse item de menu
baixará o(s) objeto(s) selecionado(s) a ser(em) desenhado(s) sob outro, quando houver
sobreposições. Se houver várias sobreposições, ela só abaixará em relação ao mais
elevado; selecionar o item de menu várias vezes até ficar na ordem que desejar.
</p> </dd>
<dt> <strong> Elevar ao topo </strong> </dt>
<p> <dd> Disponível apenas ao editar a aparência de um circuito, esse item de menu
elevará o(s) objeto(s) selecionado(s) a ser(em) desenhados acima de todos os outros
(A âncora e as portas são exceções. - Elas estarão sempre no topo.)
</p> </dd>
<dt> <strong> Baixar ao fundo </strong> </dt>
<p> <dd> Disponível apenas ao editar a aparência de um circuito, esse item de menu
abaixará o(s) objeto(s) selecionado(s) para que todos os outros objetos sejam desenhados
por cima dele(s).
</p> </dd>
<dt> <strong> Adicionar vértice </strong> </dt>
<p> <dd> Disponível apenas na edição aparência de um circuito, e um ponto tenha sido
selecionado em uma linha, poligonal ou polígono, esse item de menu inserirá um novo
vértice para a forma. Anterior à inserção, o ponto selecionado será desenhado como um
losango.
</p> </dd>
<dt> <strong> Remover vértice </strong> </dt>
<p> <dd> Disponível apenas na edição aparência de um circuito, e um vértice já existente
tenha sido selecionado em uma poligonal ou polígono, esse item de menu removerá
o vértice selecionado. Anterior à exclusão, o vértice selecionado será desenhado como um
losango dentro do quadrado que o representar. O Logisim não permitirá
remoção de um vértice de um polígono com apenas três vértices, ou em uma poligonal com
apenas dois vértices.
</p> </dd>
</dl>
<p><strong>Próximo:</strong> <a href="project.html">O menu Projeto</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>O menu Editar</title>
</head>
<body bgcolor="FFFFFF">
<h1>O menu Editar</h1>
<dl>
<dt> <strong> Desfazer <em> XX </em> </strong> </dt>
<dd> <p> Desfazer a ação executada mais recentemente que afetará a forma como o
circuito será salvo em arquivo. Notar que isso não incluirá mudanças no estado
do circuito (como acontece com as manipulações executadas pela ferramenta Testar (Poke).
</p> </dd>
<dt> <strong> Recortar </strong> </dt>
<dd> <p> Remover os componentes atualmente selecionados a partir do circuito para a
área de transferência do Logisim.
</p>
<strong> Nota: </strong> A área da transferência do Logisim é mantida em separado
da área que serve o sistema global; como resultado, recortar, copiar e
colar não irão funcionar em diferentes aplicações, incluindo até mesmo outras
que estejam executando cópias do Logisim. Se, no entanto, você tiver outros
projetos abertos no âmbito do mesmo processo Logisim, então você será
capaz de copiar, recortar e colar entre eles.
</p> </dd>
<dt> <strong> Copiar </strong> </dt>
<dd> <p> Copiar os componentes selecionados atualmente no circuito para
área de transferência do Logisim.
<br>(Ver nota do menu Recortar acima.)
</p> </dd>
<dt> <strong> Colar </strong> </dt>
<dd> <p> Colar os componentes da área de transferência do Logisim segundo
a seleção atual.
<br>(Ver nota no item do menu Recortar).
</p>
<p> Quando você colar os componentes, isso não será imediatamente realizado,
em vez disso, eles serão desenhados em cinza claro. Eles, na verdade,
não serão "efetivados" no circuito até que você mova a seleção, ou
a altere para que os componentes não estejam mais nela.
</p>
<p> A razão para esse comportamento estranho é o seguinte: para ser coerente com
seu próprio comportamento, o Logisim deverá imediatamente mesclar quaisquer conexões
tão logo sejam inseridas em um circuito; isso mudaria processo de fusão das
conexões já existentes. Quando você colar as conexões transferidas, no entanto,
você poderá colocá-las em um local diferente, e evitar a mudança inerente ao processo
de fusão que for contra a sua vontade.
</p> </dd>
<dt> <strong> Excluir </strong> </dt>
<dd> <p> Remover todos os componentes da seleção atual do circuito,
sem modificar a área de transferência.
</p> </dd>
<dt> <strong> Duplicar </strong> </dt>
<dd> <p> Criar uma cópia de todos os componentes na seleção atual. Isso é como
selecionar, copiar e colar, exceto que a duplicação não irá modificar ou usar
a área de transferência.
</p> </dd>
<dt> <strong> Selecionar tudo </strong> </dt>
<dd> <p> Selecionar todos os componentes do circuito.
</p> </dd>
<dt> <strong> Elevar a seleção </strong> </dt>
<p> <dd> Disponível somente durante a edição como deve ser a aparência de um circuito,
esse item de menu elevará o(s) objeto(s) selecionado(s) a ser(em) desenhado(s)
sobre outro quando houver sobreposições. Se o objeto selecionado for sobreposto por
outros, ele será elevado apenas sobre o que estiver mais por baixo;
selecionar o item de menu repetidamente até ficar na ordem que desejar.
</p>
<p> (Determinar se dois objetos arbitrários se sobrepõem é difícil. O Logisim usa
um algoritmo de seleção de vários pontos aleatórios em cada um dos dois objetos,
e verifica se algum ponto pertence também ao outro objeto. Às vezes, ele poderá
deixar de detectar alguma sobreposição se essa for pequena - digamos, menos de 5% de
um dos objetos.)
</p> </dd>
<dt> <strong> Baixar a seleção </strong> </dt>
<p> <dd> Disponível apenas ao editar a aparência de um circuito, esse item de menu
baixará o(s) objeto(s) selecionado(s) a ser(em) desenhado(s) sob outro, quando houver
sobreposições. Se houver várias sobreposições, ela só abaixará em relação ao mais
elevado; selecionar o item de menu várias vezes até ficar na ordem que desejar.
</p> </dd>
<dt> <strong> Elevar ao topo </strong> </dt>
<p> <dd> Disponível apenas ao editar a aparência de um circuito, esse item de menu
elevará o(s) objeto(s) selecionado(s) a ser(em) desenhados acima de todos os outros
(A âncora e as portas são exceções. - Elas estarão sempre no topo.)
</p> </dd>
<dt> <strong> Baixar ao fundo </strong> </dt>
<p> <dd> Disponível apenas ao editar a aparência de um circuito, esse item de menu
abaixará o(s) objeto(s) selecionado(s) para que todos os outros objetos sejam desenhados
por cima dele(s).
</p> </dd>
<dt> <strong> Adicionar vértice </strong> </dt>
<p> <dd> Disponível apenas na edição aparência de um circuito, e um ponto tenha sido
selecionado em uma linha, poligonal ou polígono, esse item de menu inserirá um novo
vértice para a forma. Anterior à inserção, o ponto selecionado será desenhado como um
losango.
</p> </dd>
<dt> <strong> Remover vértice </strong> </dt>
<p> <dd> Disponível apenas na edição aparência de um circuito, e um vértice já existente
tenha sido selecionado em uma poligonal ou polígono, esse item de menu removerá
o vértice selecionado. Anterior à exclusão, o vértice selecionado será desenhado como um
losango dentro do quadrado que o representar. O Logisim não permitirá
remoção de um vértice de um polígono com apenas três vértices, ou em uma poligonal com
apenas dois vértices.
</p> </dd>
</dl>
<p><strong>Próximo:</strong> <a href="project.html">O menu Projeto</a>.</p>
</body>
</html>

264
doc/pt/html/guide/menu/file.html
View File

@ -1,132 +1,132 @@
<html>
<head>
<title>O menu Arquivo (File)</title>
</head>
<body bgcolor="FFFFFF">
<h1>O menu Arquivo (File)</h1>
<dl>
<dt> <strong> Novo </strong> </dt>
<dd> <p> Abrir um novo projeto em uma nova janela. O projeto irá
inicialmente ser uma cópia do <a href="../prefs/template.html">
gabarito atualmente selecionado</a>.
</p> </dd>
<dt> <strong> Abrir ...</strong> </dt>
<dd> <p> Abrir um arquivo existente como um projeto em uma nova janela.
</p> </dd>
<dt> <strong> Fechar </strong> </dt>
<dd> <p> Fechar todas as janelas associadas atualmente com o projeto em foco.
</p> </dd>
<dt> <strong> Salvar </strong> </dt>
<dd> <p> Salvar o projeto atualmente em foco, substituindo o que estiver
anteriormente no arquivo.
</p> </dd>
<dt> <strong> Salvar como ... </strong> </dt>
<dd> <p> Salvar o projeto atualmente em foco, solicitando que o usuário
salve em um arquivo diferente do anterior.
</p> </dd>
<dt> <strong> Exportar imagem ... </strong> </dt>
<dd> <p> Criar arquivo de imagem (ou imagens) correspondente(s) aos circuitos.
A caixa de diálogo de configuração será descrita abaixo.
</p> </dd>
<dt> <strong> Imprimir ... </strong> </dt>
<dd> <p> Enviar circuito(s) para uma impressora. A caixa de diálogo de configuração
será descrita abaixo.
</p> </dd>
<dt> <strong> Preferências ... </strong> </dt>
<dd> <p> Exibir a janela <a href="../prefs/index.html"> preferências da aplicação </a>
(Em sistemas Mac OS, isso irá aparecer no menu do Logisim.)
</p> </dd>
<dt> Sair <strong> </strong> </dt>
<dd> <p> Fechar todos os projetos atualmente abertos e terminar o Logisim.
(Em sistemas Mac OS, isso irá aparecer como Quit no menu do Logisim.)
</p> </dd>
</dl>
<h2> Configurar exportação </h2>
<p> Ao selecionar Exportar imagem ..., o Logisim exibirá uma caixa de diálogo
com quatro opções:
</p>
<ul>
<li> <b> Circuitos: </b> Uma lista onde você poderá selecionar um ou mais circuitos
que deverão ser exportados em arquivos de imagem. (Circuitos em branco não serão
exibidos como opções.)
</li>
<li> <b> Formato da Imagem: </b> Você poderá criar PNG, GIF e JPEG. Recomendamos os
arquivos PNG. O formato GIF é bem antigo, e no formato JPEG poderão ser
introduzidos outros elementos na imagem, uma vez que esse formato é realmente mais
significativo para imagens fotográficas.
</li>
<li> <b> Fator de escala: </b> Você poderá dimensionar as imagens que serão
transferidas para os arquivos de imagem usando esse controle.
</li>
<li> <b> Ver impressora: </b> Se quiser usar
"<a href="../opts/canvas.html"> prévia da impressão </a>" ao exportar circuitos.
</li>
</ul>
<p> Após clicar em OK, o Logisim irá mostrar uma janela de seleção de arquivos
em caixa de diálogo. Se você já tiver selecionado um circuito, indicar então
o arquivo no qual a imagem deverá ser colocada. Se você tiver selecionado vários
circuitos, escolher uma pasta (diretório) onde os arquivos deverão ser colocados;
o Logisim providenciará os nomes das imagens com base nos nomes dos circuitos
(<tt> main.png </tt>, por exemplo).
</p>
<h2> Configurar impressão </h2>
<p> Quando você escolher Imprimir ..., o Logisim exibirá uma caixa de diálogo para
configurar o que será impresso.
</p>
<ul>
<li> <b> Circuitos: </b> Exibirá uma lista onde você poderá selecionar um ou mais
circuitos para serem impressos. (Circuitos em branco não serão exibidos como opções).
O Logisim irá imprimir um circuito por página. Se o circuito for muito
grande para a página, a imagem será redimensionada convenientemente.
</li>
<li> <b> Cabeçalho: </b> Mostrará o texto que deverá aparecer centrado na parte
superior de cada página. As seguintes substituições serão feitas no texto.
<center> <table>
<tr> <td> <tt> n% </tt> </td> Nome <td> do circuito na página </td> </tr>
<tr> <td> <tt>% p </tt> </td> Número de página </td> </tr>
<tr> <td>% <tt> P </tt> </td> Total de páginas </td> </tr>
<tr> <td> <tt>%% </tt> </td> Um único sinal ('%')</td> </tr>
</table> </center> </li>
<li> <b> Girar para ajustar: </b> Se estiver assinalada, irá o Logisim rotacionar
cada circuito em 90 graus, quando o circuito for muito grande para
caber a página, e não precisar ser escalado para menor, se puder ser girado em 90 graus.
</li>
<li> <b> Ver impressão: </b> Se quiser usar
"<a href="../opts/canvas.html"> prévia da impressão </a>" ao exportar os circuitos.
</li>
</ul>
<p> Após clicar em OK, o Logisim irá mostrar a configuração da página padrão
em uma caixa de diálogo antes de imprimir os circuitos.
</p>
<p><strong>Próximo:</strong> <a href="edit.html">O menu Editar</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>O menu Arquivo (File)</title>
</head>
<body bgcolor="FFFFFF">
<h1>O menu Arquivo (File)</h1>
<dl>
<dt> <strong> Novo </strong> </dt>
<dd> <p> Abrir um novo projeto em uma nova janela. O projeto irá
inicialmente ser uma cópia do <a href="../prefs/template.html">
gabarito atualmente selecionado</a>.
</p> </dd>
<dt> <strong> Abrir ...</strong> </dt>
<dd> <p> Abrir um arquivo existente como um projeto em uma nova janela.
</p> </dd>
<dt> <strong> Fechar </strong> </dt>
<dd> <p> Fechar todas as janelas associadas atualmente com o projeto em foco.
</p> </dd>
<dt> <strong> Salvar </strong> </dt>
<dd> <p> Salvar o projeto atualmente em foco, substituindo o que estiver
anteriormente no arquivo.
</p> </dd>
<dt> <strong> Salvar como ... </strong> </dt>
<dd> <p> Salvar o projeto atualmente em foco, solicitando que o usuário
salve em um arquivo diferente do anterior.
</p> </dd>
<dt> <strong> Exportar imagem ... </strong> </dt>
<dd> <p> Criar arquivo de imagem (ou imagens) correspondente(s) aos circuitos.
A caixa de diálogo de configuração será descrita abaixo.
</p> </dd>
<dt> <strong> Imprimir ... </strong> </dt>
<dd> <p> Enviar circuito(s) para uma impressora. A caixa de diálogo de configuração
será descrita abaixo.
</p> </dd>
<dt> <strong> Preferências ... </strong> </dt>
<dd> <p> Exibir a janela <a href="../prefs/index.html"> preferências da aplicação </a>
(Em sistemas Mac OS, isso irá aparecer no menu do Logisim.)
</p> </dd>
<dt> Sair <strong> </strong> </dt>
<dd> <p> Fechar todos os projetos atualmente abertos e terminar o Logisim.
(Em sistemas Mac OS, isso irá aparecer como Quit no menu do Logisim.)
</p> </dd>
</dl>
<h2> Configurar exportação </h2>
<p> Ao selecionar Exportar imagem ..., o Logisim exibirá uma caixa de diálogo
com quatro opções:
</p>
<ul>
<li> <b> Circuitos: </b> Uma lista onde você poderá selecionar um ou mais circuitos
que deverão ser exportados em arquivos de imagem. (Circuitos em branco não serão
exibidos como opções.)
</li>
<li> <b> Formato da Imagem: </b> Você poderá criar PNG, GIF e JPEG. Recomendamos os
arquivos PNG. O formato GIF é bem antigo, e no formato JPEG poderão ser
introduzidos outros elementos na imagem, uma vez que esse formato é realmente mais
significativo para imagens fotográficas.
</li>
<li> <b> Fator de escala: </b> Você poderá dimensionar as imagens que serão
transferidas para os arquivos de imagem usando esse controle.
</li>
<li> <b> Ver impressora: </b> Se quiser usar
"<a href="../opts/canvas.html"> prévia da impressão </a>" ao exportar circuitos.
</li>
</ul>
<p> Após clicar em OK, o Logisim irá mostrar uma janela de seleção de arquivos
em caixa de diálogo. Se você já tiver selecionado um circuito, indicar então
o arquivo no qual a imagem deverá ser colocada. Se você tiver selecionado vários
circuitos, escolher uma pasta (diretório) onde os arquivos deverão ser colocados;
o Logisim providenciará os nomes das imagens com base nos nomes dos circuitos
(<tt> main.png </tt>, por exemplo).
</p>
<h2> Configurar impressão </h2>
<p> Quando você escolher Imprimir ..., o Logisim exibirá uma caixa de diálogo para
configurar o que será impresso.
</p>
<ul>
<li> <b> Circuitos: </b> Exibirá uma lista onde você poderá selecionar um ou mais
circuitos para serem impressos. (Circuitos em branco não serão exibidos como opções).
O Logisim irá imprimir um circuito por página. Se o circuito for muito
grande para a página, a imagem será redimensionada convenientemente.
</li>
<li> <b> Cabeçalho: </b> Mostrará o texto que deverá aparecer centrado na parte
superior de cada página. As seguintes substituições serão feitas no texto.
<center> <table>
<tr> <td> <tt> n% </tt> </td> Nome <td> do circuito na página </td> </tr>
<tr> <td> <tt>% p </tt> </td> Número de página </td> </tr>
<tr> <td>% <tt> P </tt> </td> Total de páginas </td> </tr>
<tr> <td> <tt>%% </tt> </td> Um único sinal ('%')</td> </tr>
</table> </center> </li>
<li> <b> Girar para ajustar: </b> Se estiver assinalada, irá o Logisim rotacionar
cada circuito em 90 graus, quando o circuito for muito grande para
caber a página, e não precisar ser escalado para menor, se puder ser girado em 90 graus.
</li>
<li> <b> Ver impressão: </b> Se quiser usar
"<a href="../opts/canvas.html"> prévia da impressão </a>" ao exportar os circuitos.
</li>
</ul>
<p> Após clicar em OK, o Logisim irá mostrar a configuração da página padrão
em uma caixa de diálogo antes de imprimir os circuitos.
</p>
<p><strong>Próximo:</strong> <a href="edit.html">O menu Editar</a>.</p>
</body>
</html>

56
doc/pt/html/guide/menu/index.html
View File

@ -1,28 +1,28 @@
<html>
<head>
<title>Menu Referência (Reference)</title>
</head>
<body bgcolor="FFFFFF">
<h1>Menu Referência (Reference)</h1>
<p> Esta seção explica os seis menus que acompanham a janela principal do Logisim.
</p>
<blockquote>
<a href="file.html"> O menu Arquivo </a>
<br> <a href="edit.html"> O menu Editar </a>
<br> <a href="project.html"> O menu Projeto </a>
<br> <a href="simulate.html"> O menu Simular </a>
<br> <a href="winhelp.html"> Os menus Janela e Ajuda </a>
</blockquote>
Muitos itens do menu se referem especificamente ao projeto em foco.
Mas algumas janelas do Logisim (particularmente <a href ="../ analisar / index.html ">
Análise Combinacional </a> e <a href="../prefs/index.html"> Preferências da Aplicação </a>)
não estão associadas aos projetos. Para essas janelas, os itens de menu específicos
de projeto estarão desativados.
<p><strong>Próximo:</strong> <a href="file.html">O menu Arquivo (File)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Menu Referência (Reference)</title>
</head>
<body bgcolor="FFFFFF">
<h1>Menu Referência (Reference)</h1>
<p> Esta seção explica os seis menus que acompanham a janela principal do Logisim.
</p>
<blockquote>
<a href="file.html"> O menu Arquivo </a>
<br> <a href="edit.html"> O menu Editar </a>
<br> <a href="project.html"> O menu Projeto </a>
<br> <a href="simulate.html"> O menu Simular </a>
<br> <a href="winhelp.html"> Os menus Janela e Ajuda </a>
</blockquote>
Muitos itens do menu se referem especificamente ao projeto em foco.
Mas algumas janelas do Logisim (particularmente <a href ="../ analisar / index.html ">
Análise Combinacional </a> e <a href="../prefs/index.html"> Preferências da Aplicação </a>)
não estão associadas aos projetos. Para essas janelas, os itens de menu específicos
de projeto estarão desativados.
<p><strong>Próximo:</strong> <a href="file.html">O menu Arquivo (File)</a>.</p>
</body>
</html>

262
doc/pt/html/guide/menu/project.html
View File

@ -1,131 +1,131 @@
<html>
<head>
<title> O menu Projeto (Project)</title>
</head>
<body bgcolor="FFFFFF">
<h1>O menu Projeto (Project)</h1>
<dl>
<dt> <strong> Adicionar Circuito ... (Add Circuit ...) </strong> </dt>
<dd> <p> Adicionar um novo circuito para o projeto atual.
Logisim irá requerer o nome do novo circuito.
O nome não deverá coincidir com o de outros circuitos existentes no projeto.
</p> </dd>
<dt> <strong> Carregar Biblioteca (Load Library) </strong> </dt>
<dd> <p> href="../attrlib/explore.html"> Carregar uma biblioteca </a> para o
projeto. Você poderá carregar três tipos de bibliotecas, como explicado
<a href ="../attrlib/explore.html "> em outras partes do
<em> Guia do Usuário</em></a>.
</p> </dd>
<dt> <strong> Decarregar Bibliotecas ... (Unload Libraries ...) </strong> </dt>
<dd> <p> Descarregar bibliotecas atualmente no projeto.
O Logisim não permitirá que você descarregue bibliotecas em uso,
incluindo aquelas cujos componentes que aparecerem em quaisquer circuitos do projeto,
bem como aquelas com itens que aparecerem na barra de ferramentas ou
que estiverem mapeados para o mouse.
</p> </dd>
<dt> <strong> Mover Circuito Para Cima (Move Circuit Up) </strong> </dt>
<dd> <p> Mover o circuito exibido atualmente uma posição para cima na lista de
circuitos do projeto, como mostrado no painel do Explorer.
</p> </dd>
<dt> <strong> Mover Circuito Para Baixo (Move Circuit Down) </strong> </dt>
<dd> <p> Mover o circuito exibido atualmente uma posição para baixo na lista de
circuitos do projeto, como mostrado no painel do Explorer.
</p> </dd>
<dt> <strong> Definir Como Circuito Principal (Set As Main Circuit) </strong> </dt>
<dd> <p> Definir o circuito a ser exibido no momento como <q> circuito principal</q>
do projeto. (Esse item de menu ficará cinza se o circuito atual for o principal.)
Isso significa que ele será o circuito a aparecer primeiro quando o arquivo do projeto
for aberto.
</p> </dd>
<dt> <strong> Editar <i>Layout</i> do Circuito (Edit Circuit Layout) </strong> </dt>
<dd> <p> Permitir editar o <i>layout</i> dos componentes que
determinam como o circuito trabalha. Isso é o que o programa faz ao iniciar-se,
e como você provavelmente irá editar <i>layouts</i> de circuitos na maioria das vezes
usando o próprio Logisim, esse item de menu normalmente estará desativado.
</p> </dd>
<dt> <strong> Editar Aparência de Circuito (Edit Circuit Appearance) </strong> </dt>
<dd> <p> Permitir editar o circuito que estiver representado
quando ele é usado como um subcircuito dentro de outro.
Por padrão, o circuito será representado por um retângulo com um <q> entalhe</q> cinza
em sua face norte, mas essa opção de menu lhe permitirá desenhar uma aparência
diferente para o subcircuito.
</p> </dd>
<dt> <strong> Restaurar Aparência Padrão (Revert To Default Appearance) </strong> </dt>
<dd> <p> Se a aparência do circuito tiver sido editada, esse item de menu irá restaurar
a aparência padrão para o retângulo com entalhe.
O item de menu será ativado somente quando houver edição da aparência do circuito.
</p> </dd>
<dt> <strong> Remover Circuito (Remove Circuit) </strong> </dt>
<dd> <p> Remover o circuito do projeto em exibição.
O Logisim irá impedir a remoção de circuitos estejam em uso como subcircuitos,
bem como impedí-lo de retirar o último circuito de um projeto.
</p> </dd>
<dt> <strong> Analisar Circuito (Analyze Circuit) </strong> </dt>
<dd> <p> Computar a tabela-verdade e expressões lógicas correspondentes
ao circuito, exibindo-as na janela
<a href="../analyze/index.html"> Análise Combinatória</a>.
O processo de análise só será válido para circuitos combinacionais.
Uma descrição completa do processo de análise é descrita na seção
<a href="../analyze/open.html"> Análise Combinatória</a>.
</p> </dd>
<dt> <strong> Obter Estatísticas Do Circuito (Get Circuit Statistics) </strong> </dt>
<dd> <p> Mostrar janela contendo as estatísticas sobre os componentes utilizados pelo
circuito atual. O diálogo terá uma tabela com cinco colunas:
</p>
<ul>
<li> Componente: O nome do componente </li>
<li> Biblioteca: O nome da biblioteca de origem do componente </li>
<li> Simples: O número de vezes que o componente aparecer diretamente no circuito visto </li>.
<li> Exclusivas: O número de vezes que o componente aparecer na hierarquia do circuito,
ononde cada subcircuito dentro da hierarquia será contabilizado apenas uma vez. </li>
<li> Recursivas: O número de vezes que o componente aparecer na hierarquia do circuito,
ononde cada subcircuito será contado quantas vezes aparecer na hierarquia. </li>
</ul>
<p> A distinção entre <q> exclusivas</q> e <q> recursivas</q> é mais fácil de se
explicar considerando o multiplexador 4:1 construído com três multiplexadores 2:1
como na seção <q> <a href="../subcirc/using.html"> Usando subcircuitos </a> </q>.
O multiplexador 2:1 contém duas portas AND (e o circuito 4:1, nenhuma),
sendo que a contagem <q> exclusiva</q> de portas AND seria 2,
mas se você fosse construir o multiplexador 4:1 utilizando esse
diagrama, você realmente precisaria de 2 portas AND para cada um dos
três multiplexadores 2:1, assim a contagem <q> recursiva</q> seria 6.
</p>
<p> Se você usar circuitos de uma biblioteca Logisim, os componentes serão
considerado <q> caixas pretas </q>: o conteúdo dos circuitos da biblioteca não serão
usados na contagem original e recursiva.
</p> </dd>
<dt> <strong> Mostrar Barra De Projeto (Show Project Toolbar) </strong> </dt>
<dd> <p> Quando selecionado, esse item de menu mostrará uma pequena barra de ferramentas
acima do painel Explorer, permitindo que o usuário tenha fácil acesso aos itens
adicionar, renomear, reordenar e remover circuitos em um projeto.
A barra de ferramentas também oferecerá suporte a alternância entre
a edição de <i>layout</i> e a aparência do circuito.
</p> </dd>
<dt><strong> Opções ... (Options ...) </strong> </dt>
<dd><p> Abrir a janela <a href="../opts/index.html">Opções de Projeto</a>.
</p></dd>
</dl>
<p><strong>Próximo:</strong> <a href="simulate.html">O menu Simular (Simulate)</a>.
</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title> O menu Projeto (Project)</title>
</head>
<body bgcolor="FFFFFF">
<h1>O menu Projeto (Project)</h1>
<dl>
<dt> <strong> Adicionar Circuito ... (Add Circuit ...) </strong> </dt>
<dd> <p> Adicionar um novo circuito para o projeto atual.
Logisim irá requerer o nome do novo circuito.
O nome não deverá coincidir com o de outros circuitos existentes no projeto.
</p> </dd>
<dt> <strong> Carregar Biblioteca (Load Library) </strong> </dt>
<dd> <p> href="../attrlib/explore.html"> Carregar uma biblioteca </a> para o
projeto. Você poderá carregar três tipos de bibliotecas, como explicado
<a href ="../attrlib/explore.html "> em outras partes do
<em> Guia do Usuário</em></a>.
</p> </dd>
<dt> <strong> Decarregar Bibliotecas ... (Unload Libraries ...) </strong> </dt>
<dd> <p> Descarregar bibliotecas atualmente no projeto.
O Logisim não permitirá que você descarregue bibliotecas em uso,
incluindo aquelas cujos componentes que aparecerem em quaisquer circuitos do projeto,
bem como aquelas com itens que aparecerem na barra de ferramentas ou
que estiverem mapeados para o mouse.
</p> </dd>
<dt> <strong> Mover Circuito Para Cima (Move Circuit Up) </strong> </dt>
<dd> <p> Mover o circuito exibido atualmente uma posição para cima na lista de
circuitos do projeto, como mostrado no painel do Explorer.
</p> </dd>
<dt> <strong> Mover Circuito Para Baixo (Move Circuit Down) </strong> </dt>
<dd> <p> Mover o circuito exibido atualmente uma posição para baixo na lista de
circuitos do projeto, como mostrado no painel do Explorer.
</p> </dd>
<dt> <strong> Definir Como Circuito Principal (Set As Main Circuit) </strong> </dt>
<dd> <p> Definir o circuito a ser exibido no momento como <q> circuito principal</q>
do projeto. (Esse item de menu ficará cinza se o circuito atual for o principal.)
Isso significa que ele será o circuito a aparecer primeiro quando o arquivo do projeto
for aberto.
</p> </dd>
<dt> <strong> Editar <i>Layout</i> do Circuito (Edit Circuit Layout) </strong> </dt>
<dd> <p> Permitir editar o <i>layout</i> dos componentes que
determinam como o circuito trabalha. Isso é o que o programa faz ao iniciar-se,
e como você provavelmente irá editar <i>layouts</i> de circuitos na maioria das vezes
usando o próprio Logisim, esse item de menu normalmente estará desativado.
</p> </dd>
<dt> <strong> Editar Aparência de Circuito (Edit Circuit Appearance) </strong> </dt>
<dd> <p> Permitir editar o circuito que estiver representado
quando ele é usado como um subcircuito dentro de outro.
Por padrão, o circuito será representado por um retângulo com um <q> entalhe</q> cinza
em sua face norte, mas essa opção de menu lhe permitirá desenhar uma aparência
diferente para o subcircuito.
</p> </dd>
<dt> <strong> Restaurar Aparência Padrão (Revert To Default Appearance) </strong> </dt>
<dd> <p> Se a aparência do circuito tiver sido editada, esse item de menu irá restaurar
a aparência padrão para o retângulo com entalhe.
O item de menu será ativado somente quando houver edição da aparência do circuito.
</p> </dd>
<dt> <strong> Remover Circuito (Remove Circuit) </strong> </dt>
<dd> <p> Remover o circuito do projeto em exibição.
O Logisim irá impedir a remoção de circuitos estejam em uso como subcircuitos,
bem como impedí-lo de retirar o último circuito de um projeto.
</p> </dd>
<dt> <strong> Analisar Circuito (Analyze Circuit) </strong> </dt>
<dd> <p> Computar a tabela-verdade e expressões lógicas correspondentes
ao circuito, exibindo-as na janela
<a href="../analyze/index.html"> Análise Combinatória</a>.
O processo de análise só será válido para circuitos combinacionais.
Uma descrição completa do processo de análise é descrita na seção
<a href="../analyze/open.html"> Análise Combinatória</a>.
</p> </dd>
<dt> <strong> Obter Estatísticas Do Circuito (Get Circuit Statistics) </strong> </dt>
<dd> <p> Mostrar janela contendo as estatísticas sobre os componentes utilizados pelo
circuito atual. O diálogo terá uma tabela com cinco colunas:
</p>
<ul>
<li> Componente: O nome do componente </li>
<li> Biblioteca: O nome da biblioteca de origem do componente </li>
<li> Simples: O número de vezes que o componente aparecer diretamente no circuito visto </li>.
<li> Exclusivas: O número de vezes que o componente aparecer na hierarquia do circuito,
ononde cada subcircuito dentro da hierarquia será contabilizado apenas uma vez. </li>
<li> Recursivas: O número de vezes que o componente aparecer na hierarquia do circuito,
ononde cada subcircuito será contado quantas vezes aparecer na hierarquia. </li>
</ul>
<p> A distinção entre <q> exclusivas</q> e <q> recursivas</q> é mais fácil de se
explicar considerando o multiplexador 4:1 construído com três multiplexadores 2:1
como na seção <q> <a href="../subcirc/using.html"> Usando subcircuitos </a> </q>.
O multiplexador 2:1 contém duas portas AND (e o circuito 4:1, nenhuma),
sendo que a contagem <q> exclusiva</q> de portas AND seria 2,
mas se você fosse construir o multiplexador 4:1 utilizando esse
diagrama, você realmente precisaria de 2 portas AND para cada um dos
três multiplexadores 2:1, assim a contagem <q> recursiva</q> seria 6.
</p>
<p> Se você usar circuitos de uma biblioteca Logisim, os componentes serão
considerado <q> caixas pretas </q>: o conteúdo dos circuitos da biblioteca não serão
usados na contagem original e recursiva.
</p> </dd>
<dt> <strong> Mostrar Barra De Projeto (Show Project Toolbar) </strong> </dt>
<dd> <p> Quando selecionado, esse item de menu mostrará uma pequena barra de ferramentas
acima do painel Explorer, permitindo que o usuário tenha fácil acesso aos itens
adicionar, renomear, reordenar e remover circuitos em um projeto.
A barra de ferramentas também oferecerá suporte a alternância entre
a edição de <i>layout</i> e a aparência do circuito.
</p> </dd>
<dt><strong> Opções ... (Options ...) </strong> </dt>
<dd><p> Abrir a janela <a href="../opts/index.html">Opções de Projeto</a>.
</p></dd>
</dl>
<p><strong>Próximo:</strong> <a href="simulate.html">O menu Simular (Simulate)</a>.
</p>
</body>
</html>

170
doc/pt/html/guide/menu/simulate.html
View File

@ -1,85 +1,85 @@
<html>
<head>
<title>O menu Simular (Simulate)</title>
</head>
<body bgcolor="FFFFFF">
<h1>O menu Simular (Simulate)</h1>
<dl>
<dt> <strong> Simulação ativada </strong> </dt>
<p> <dd> Se marcada, os circuitos serão vistos "ao vivo". Isso é, os
valores de propagação através do circuito serão atualizado a cada
teste ou alteração no circuito.
</p>
<p> A opção será automaticamente desmarcada se
<a href="../prop/oscillate.html"> oscilação no circuito </a> for
detectada.
</p> </dd>
<dt> <strong> Reiniciar simulação (Reset Simulation) </strong> </dt>
<dd> <p> Limpar tudo sobre o estado atual do circuito, de modo que
será como se você tivesse acabado de abrir o arquivo novamente. Se você estiver vendo
o estado de um subcircuito, a hierarquia inteira será eliminada.
</p> </dd>
<dt> <strong> Simulação passo-a-passo (Step Simulation) </strong> </dt>
<dd> <p> Avançar a simulação um passo à frente. Por exemplo, um sinal pode acabar
entrando em uma porta durante uma etapa, mas a porta não irá mostrar um sinal diferente
até o próximo passo da simulação. Para ajudar a identificar quais pontos mudaram no
circuito em geral, todos os pontos cujos valores forem modificados serão
indicados por um círculo azul; se um subcircuito contiver todos os seus pontos
alterados (ou em seus subcircuitos, recursivamente), então ele será desenhado
com um contorno azul.
</p> </dd>
<dt> <strong> Ir para estado (Go Out To State) </strong> </dt>
<dd> <p> Quando você <a href="../subcirc/debug.html"> desviar para um estado de um
subcircuito </a>, através do menu <i>pop-up</i>, a opção <q> Ir para estado </q>
listará os circuitos acima daquele em foco. Se selecionar um deles,
o circuito correspondente será mostrado.
</p> </dd>
<dt> <strong> Seguir a partir do Estado (Go In To State) </strong> </dt>
<dd> <p> Se você já entrou em um estado de subcircuito e depois desviou-se
para fora, esse submenu listará os subcircuitos subjacentes aos atuais.
Se selecionar um deles, o circuito correspondente será mostrado.
</p> </dd>
<dt> <strong> Pulso unitário (Tick Once) </strong> </dt>
<dd> <p> Executar um passo na simulação. Isso pode ser útil
quando você acionar o <i>clock</i> manualmente, em especial quando ele estiver
em circuito diferente daquele que estiver sendo visto.
</p> </dd>
<dt> <strong> Pulsos ativados (Ticks Enabled) </strong> </dt>
<dd> <p> Iniciar automaticamente alternâncias do <i>clock</i>. Isso terá efeito
somente se o circuito contiver dispositivos do tipo <i>clock</i> (na biblioteca Base).
A opção é desabilitada por padrão.
</p> </dd>
<dt><strong> Frequência de pulso (Tick Frequency) </strong></dt>
<dd> <p> Selecionar com que frequência ocorreráo as alternâncias do <i>clock</i>.
Por exemplo, 8 Hz significa que as variações ocorrerão oito vezes por segundo.
Um pulso (<i>tick</i>) é a unidade básica de medida para a velocidade do <i>clock</i>.
</p>
<p> Notar que a velocidade do <i>clock</i> será menor do que a dos ciclos:
a variação mais rápida do <i>clock</i> deverá passar por um ciclo em nível alto
e outro em nível baixo; esse <i>clock</i> teria um período de 4 Hz enquanto a
alternância de ciclos ocorrer ocorrem em 8 Hz. </p> </dd>
<dt> <strong> Registro ... </strong> </dt
<dd> <p> Entrar no <a href="../log/index.html"> módulo Registro</a>, o que
facilitará o anotar e guardar valores automaticamente em um circuito a medida
em que a simulação avançar.
</p> </dd>
</dl>
<p><strong>Próximo:</strong> <a href="winhelp.html">Menus Janela e Ajuda</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>O menu Simular (Simulate)</title>
</head>
<body bgcolor="FFFFFF">
<h1>O menu Simular (Simulate)</h1>
<dl>
<dt> <strong> Simulação ativada </strong> </dt>
<p> <dd> Se marcada, os circuitos serão vistos "ao vivo". Isso é, os
valores de propagação através do circuito serão atualizado a cada
teste ou alteração no circuito.
</p>
<p> A opção será automaticamente desmarcada se
<a href="../prop/oscillate.html"> oscilação no circuito </a> for
detectada.
</p> </dd>
<dt> <strong> Reiniciar simulação (Reset Simulation) </strong> </dt>
<dd> <p> Limpar tudo sobre o estado atual do circuito, de modo que
será como se você tivesse acabado de abrir o arquivo novamente. Se você estiver vendo
o estado de um subcircuito, a hierarquia inteira será eliminada.
</p> </dd>
<dt> <strong> Simulação passo-a-passo (Step Simulation) </strong> </dt>
<dd> <p> Avançar a simulação um passo à frente. Por exemplo, um sinal pode acabar
entrando em uma porta durante uma etapa, mas a porta não irá mostrar um sinal diferente
até o próximo passo da simulação. Para ajudar a identificar quais pontos mudaram no
circuito em geral, todos os pontos cujos valores forem modificados serão
indicados por um círculo azul; se um subcircuito contiver todos os seus pontos
alterados (ou em seus subcircuitos, recursivamente), então ele será desenhado
com um contorno azul.
</p> </dd>
<dt> <strong> Ir para estado (Go Out To State) </strong> </dt>
<dd> <p> Quando você <a href="../subcirc/debug.html"> desviar para um estado de um
subcircuito </a>, através do menu <i>pop-up</i>, a opção <q> Ir para estado </q>
listará os circuitos acima daquele em foco. Se selecionar um deles,
o circuito correspondente será mostrado.
</p> </dd>
<dt> <strong> Seguir a partir do Estado (Go In To State) </strong> </dt>
<dd> <p> Se você já entrou em um estado de subcircuito e depois desviou-se
para fora, esse submenu listará os subcircuitos subjacentes aos atuais.
Se selecionar um deles, o circuito correspondente será mostrado.
</p> </dd>
<dt> <strong> Pulso unitário (Tick Once) </strong> </dt>
<dd> <p> Executar um passo na simulação. Isso pode ser útil
quando você acionar o <i>clock</i> manualmente, em especial quando ele estiver
em circuito diferente daquele que estiver sendo visto.
</p> </dd>
<dt> <strong> Pulsos ativados (Ticks Enabled) </strong> </dt>
<dd> <p> Iniciar automaticamente alternâncias do <i>clock</i>. Isso terá efeito
somente se o circuito contiver dispositivos do tipo <i>clock</i> (na biblioteca Base).
A opção é desabilitada por padrão.
</p> </dd>
<dt><strong> Frequência de pulso (Tick Frequency) </strong></dt>
<dd> <p> Selecionar com que frequência ocorreráo as alternâncias do <i>clock</i>.
Por exemplo, 8 Hz significa que as variações ocorrerão oito vezes por segundo.
Um pulso (<i>tick</i>) é a unidade básica de medida para a velocidade do <i>clock</i>.
</p>
<p> Notar que a velocidade do <i>clock</i> será menor do que a dos ciclos:
a variação mais rápida do <i>clock</i> deverá passar por um ciclo em nível alto
e outro em nível baixo; esse <i>clock</i> teria um período de 4 Hz enquanto a
alternância de ciclos ocorrer ocorrem em 8 Hz. </p> </dd>
<dt> <strong> Registro ... </strong> </dt
<dd> <p> Entrar no <a href="../log/index.html"> módulo Registro</a>, o que
facilitará o anotar e guardar valores automaticamente em um circuito a medida
em que a simulação avançar.
</p> </dd>
</dl>
<p><strong>Próximo:</strong> <a href="winhelp.html">Menus Janela e Ajuda</a>.</p>
</body>
</html>

120
doc/pt/html/guide/menu/winhelp.html
View File

@ -1,60 +1,60 @@
<html>
<head>
<title>Menus Janela (Window) e Ajuda (Help)</title>
</head>
<body bgcolor="FFFFFF">
<h1>Menu Janela (Window)</h1>
<dl>
<dt><strong>Minimizar (Minimize)</strong></dt>
<dd> <p> Minimizar a janela atual.
</p> </dd>
<dt> <strong> Maximizar (Maximize) </strong> (<strong> Zoom </strong> no MacOS) </dt>
<dd> <p> Redimensionar a janela atual para tamanho de sua preferência.
</p> </dd>
<dt> Análise Combinacional <strong> </strong> </dt>
<dd> <p> Mostrar a janela <a href="../analyze/index.html"> Análise Combinacional </a>
corrente, sem alterar qualquer conteúdo.
</p> </dd>
<dt> <strong> Títulos de janela individual </em> </strong> </dt>
<dd> <p> Trazer a janela respectiva para o foco. </p> </dd>
</dl>
<h1> O menu Ajuda </h1>
<dl>
<dt> <strong> Tutorial </strong> </dt>
<dd> <p> Abrir o sistema de ajuda na seção
"<a href="../tutorial/index.html"> Beginner's Tutorial </a>" do
<em> <a href="../index.html"> Guia para ser um usuário do Logisim </a> </em>.
</p> </dd>
<dt> <strong> Guia do usuário </strong> </dt>
<dd> <p> Abrir o sistema de ajuda no
<em> <a href="../index.html"> Guia para ser um usuário do Logisim </a> </em>.
</p> </dd>
<dt> <strong> Biblioteca de Referência </strong> </dt>
<dd> <p> Abrir o sistema de ajuda na
<em> <a href="../../libs/index.html"> Biblioteca de Referência </a> </em>.
</p> </dd>
<dt> <strong> Sobre ... </strong> </dt>
<dd> <p> Exibir uma janela contendo o número da versão, bem como a tela de
apresentação.
<br> (Em MacOS, esse item ficará no menu do Logisim.)
</p> </dd>
</dl>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Menus Janela (Window) e Ajuda (Help)</title>
</head>
<body bgcolor="FFFFFF">
<h1>Menu Janela (Window)</h1>
<dl>
<dt><strong>Minimizar (Minimize)</strong></dt>
<dd> <p> Minimizar a janela atual.
</p> </dd>
<dt> <strong> Maximizar (Maximize) </strong> (<strong> Zoom </strong> no MacOS) </dt>
<dd> <p> Redimensionar a janela atual para tamanho de sua preferência.
</p> </dd>
<dt> Análise Combinacional <strong> </strong> </dt>
<dd> <p> Mostrar a janela <a href="../analyze/index.html"> Análise Combinacional </a>
corrente, sem alterar qualquer conteúdo.
</p> </dd>
<dt> <strong> Títulos de janela individual </em> </strong> </dt>
<dd> <p> Trazer a janela respectiva para o foco. </p> </dd>
</dl>
<h1> O menu Ajuda </h1>
<dl>
<dt> <strong> Tutorial </strong> </dt>
<dd> <p> Abrir o sistema de ajuda na seção
"<a href="../tutorial/index.html"> Beginner's Tutorial </a>" do
<em> <a href="../index.html"> Guia para ser um usuário do Logisim </a> </em>.
</p> </dd>
<dt> <strong> Guia do usuário </strong> </dt>
<dd> <p> Abrir o sistema de ajuda no
<em> <a href="../index.html"> Guia para ser um usuário do Logisim </a> </em>.
</p> </dd>
<dt> <strong> Biblioteca de Referência </strong> </dt>
<dd> <p> Abrir o sistema de ajuda na
<em> <a href="../../libs/index.html"> Biblioteca de Referência </a> </em>.
</p> </dd>
<dt> <strong> Sobre ... </strong> </dt>
<dd> <p> Exibir uma janela contendo o número da versão, bem como a tela de
apresentação.
<br> (Em MacOS, esse item ficará no menu do Logisim.)
</p> </dd>
</dl>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>

164
doc/pt/html/guide/opts/canvas.html
View File

@ -1,82 +1,82 @@
<html>
<head>
<title>A guia Área de Desenho (Canvas)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Área de Desenho (Canvas)</h1>
<p> Essa guia permitirá a configuração da aparência da área de desenho do circuito.
</p>
<center> <img src="canvas.png" width="393" height="324"> </center>
<p> Há oito opções. </p>
<ul>
<li> A opção <strong> Prévia da impressão </strong> quando selecionada serve para
especificar se o circuito deverá ser mostrado na tela da mesma forma como será
impresso. Normalmente estará desligado, e o Logisim exibe instruções na tela
com indicações do estado atual do circuito atual, e apresenta algumas
dicas sobre a interface do componente (mais particularmente, indicações onde
na porta OR poderiam haver conexões). A prévia da impressão, no entanto,
omitirá essas indicações de estado, e também se omitirão tais referências da interface.
</p> </li>
<li> A opção <strong> Mostrar grade (Show Grid) </strong> quando selecionada serve
para especificar se é para desenhar os pontos (marcas) no fundo,
indicando o tamanho da grade.
</p> </li>
<li> A opção <strong> Mostrar halo (Show Attribute Halo) </strong> quando selecionada
serve para especificar se é para desenhar a forma oval pálido em azul-petróleo em torno
do componente ou da ferramenta cujos atributos estão sendo exibidos atualmente na
tabela de atributos.
</p> </li>
<li> A opção <strong> Mostrar dicas de componentes (Show Component Tips) </strong>
quando selecionada serve para especificar se é para apresentar as "dicas de ferramentas"
que irão aparecer temporariamente enquanto o mouse passar sobre os componentes.
Por exemplo, se você passar o mouse sobre o pino de um componente de subcircuito,
ele irá mostrar o rótulo do pino correspondente - ou ele irá mostrar
o nome do subcircuito se não tiver rótulo. Ao passar sobre uma das
extremidades de um distribuidor ele irá dizer-lhe a que bits corresponde.
Além disso, todos os componentes das bibliotecas MUXes e DEMUXes, Aritmética e Memória
fornecerão informações sobre suas entradas e saídas.
</p> </li>
<li> A opção <strong> Manter conexões ao mover (Keep Connections When Moving) </strong>
quando selecionada serve para indicar se deverão ser acrescentados novos cabos
quando os componentes forem movidos para preservar suas conexões. Por padrão estará
ligada - embora possa ser desativada temporariamente pressionando a tecla shift
enquanto move os componentes.
Se esta opção estiver desmarcada, então o padrão será de não adicionar os cabos
durante uma movimentação. Mas você poderá ligá-lo temporariamente, pressionando
a tecla shift durante a movimentação.
</p> </li>
<li> O menu <strong> Fator para Zoom (Zoom Factor) </strong> lhe permitirá
"explodir" ou "implodir" a imagem proporcionalmente. A expansão (zoom) de um circuito
pode ser útil para demonstrações em sala de aula, onde a resolução de tela for
muito pequena para visualizar de longe; já a contração poderá ser útil para
orientar-se em um circuito muito grande.
</p> </li>
<li> O menu <strong> Primeira base quando conexão ativada
(First Radix When Wire Poked) </strong> serve para configurar como os valores serão
exibidos quando uma conexão for clicada usando a ferramenta Testar (Poke).
Ao clicar, temporariamente o valor será mostrado até que o usuário clique
em outras partes do circuito.
</p> </li>
<li> O menu <strong> Segunda base quando conexão ativada
(Second Radix When Wire Poked) </strong> serve para configurar a segunda parte
da exibição do valor.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <a href="simulate.html">A guia Simulação (Simulation)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia Área de Desenho (Canvas)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Área de Desenho (Canvas)</h1>
<p> Essa guia permitirá a configuração da aparência da área de desenho do circuito.
</p>
<center> <img src="canvas.png" width="393" height="324"> </center>
<p> Há oito opções. </p>
<ul>
<li> A opção <strong> Prévia da impressão </strong> quando selecionada serve para
especificar se o circuito deverá ser mostrado na tela da mesma forma como será
impresso. Normalmente estará desligado, e o Logisim exibe instruções na tela
com indicações do estado atual do circuito atual, e apresenta algumas
dicas sobre a interface do componente (mais particularmente, indicações onde
na porta OR poderiam haver conexões). A prévia da impressão, no entanto,
omitirá essas indicações de estado, e também se omitirão tais referências da interface.
</p> </li>
<li> A opção <strong> Mostrar grade (Show Grid) </strong> quando selecionada serve
para especificar se é para desenhar os pontos (marcas) no fundo,
indicando o tamanho da grade.
</p> </li>
<li> A opção <strong> Mostrar halo (Show Attribute Halo) </strong> quando selecionada
serve para especificar se é para desenhar a forma oval pálido em azul-petróleo em torno
do componente ou da ferramenta cujos atributos estão sendo exibidos atualmente na
tabela de atributos.
</p> </li>
<li> A opção <strong> Mostrar dicas de componentes (Show Component Tips) </strong>
quando selecionada serve para especificar se é para apresentar as "dicas de ferramentas"
que irão aparecer temporariamente enquanto o mouse passar sobre os componentes.
Por exemplo, se você passar o mouse sobre o pino de um componente de subcircuito,
ele irá mostrar o rótulo do pino correspondente - ou ele irá mostrar
o nome do subcircuito se não tiver rótulo. Ao passar sobre uma das
extremidades de um distribuidor ele irá dizer-lhe a que bits corresponde.
Além disso, todos os componentes das bibliotecas MUXes e DEMUXes, Aritmética e Memória
fornecerão informações sobre suas entradas e saídas.
</p> </li>
<li> A opção <strong> Manter conexões ao mover (Keep Connections When Moving) </strong>
quando selecionada serve para indicar se deverão ser acrescentados novos cabos
quando os componentes forem movidos para preservar suas conexões. Por padrão estará
ligada - embora possa ser desativada temporariamente pressionando a tecla shift
enquanto move os componentes.
Se esta opção estiver desmarcada, então o padrão será de não adicionar os cabos
durante uma movimentação. Mas você poderá ligá-lo temporariamente, pressionando
a tecla shift durante a movimentação.
</p> </li>
<li> O menu <strong> Fator para Zoom (Zoom Factor) </strong> lhe permitirá
"explodir" ou "implodir" a imagem proporcionalmente. A expansão (zoom) de um circuito
pode ser útil para demonstrações em sala de aula, onde a resolução de tela for
muito pequena para visualizar de longe; já a contração poderá ser útil para
orientar-se em um circuito muito grande.
</p> </li>
<li> O menu <strong> Primeira base quando conexão ativada
(First Radix When Wire Poked) </strong> serve para configurar como os valores serão
exibidos quando uma conexão for clicada usando a ferramenta Testar (Poke).
Ao clicar, temporariamente o valor será mostrado até que o usuário clique
em outras partes do circuito.
</p> </li>
<li> O menu <strong> Segunda base quando conexão ativada
(Second Radix When Wire Poked) </strong> serve para configurar a segunda parte
da exibição do valor.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <a href="simulate.html">A guia Simulação (Simulation)</a>.</p>
</body>
</html>

82
doc/pt/html/guide/opts/index.html
View File

@ -1,41 +1,41 @@
<html>
<head>
<title>Opções de projeto</title>
</head>
<body bgcolor="FFFFFF">
<h1>Opções de projeto</h1>
<p> O Logisim oferece dois tipos de opções de configuração:
<em> preferências de aplicação </em> e <em> opções projeto </em>.
As preferências do aplicativo abrangem todos os projetos abertos,
enquanto as opções de projeto são específicas para que um projeto apenas.
Esta seção discutirá as opções de projeto;
<a href="../prefs/"> preferências da aplicação </a> serão descritas em outra
seção.
</p>
<p> Você poderá visualizar e editar as opções de projeto através de "Opções ...
no menu de projeto. A janela Opções tem quatro guias.
</p>
<center> <img src="canvas.png" width="393" height="324"> </center>
<p> Apresentaremos cada uma dessas guias separadamente. </p>
<blockquote>
<a href="canvas.html"> A guia Canvas </a>
<br> <a href="simulate.html"> A guia Simulação </a>
<br> <a href="toolbar.html"> A guia Barra de Ferramentas </a>
<br> <a href="mouse.html"> O guia Mouse </a>
</blockquote>
<p> Na parte inferior da janela está o botão para restaurar ao modelo
do gabarito. Quando clicado, todas as opções e alterações nos atributos de ferramenta
voltarão às definições do gabarito atual (tal como selecionado no âmbito das
<a href="../prefs/"> preferências da aplicação </a >).
</p>
<p><strong>Próximo:</strong> <a href="canvas.html">A guia Área de Desenho (Canvas)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Opções de projeto</title>
</head>
<body bgcolor="FFFFFF">
<h1>Opções de projeto</h1>
<p> O Logisim oferece dois tipos de opções de configuração:
<em> preferências de aplicação </em> e <em> opções projeto </em>.
As preferências do aplicativo abrangem todos os projetos abertos,
enquanto as opções de projeto são específicas para que um projeto apenas.
Esta seção discutirá as opções de projeto;
<a href="../prefs/"> preferências da aplicação </a> serão descritas em outra
seção.
</p>
<p> Você poderá visualizar e editar as opções de projeto através de "Opções ...
no menu de projeto. A janela Opções tem quatro guias.
</p>
<center> <img src="canvas.png" width="393" height="324"> </center>
<p> Apresentaremos cada uma dessas guias separadamente. </p>
<blockquote>
<a href="canvas.html"> A guia Canvas </a>
<br> <a href="simulate.html"> A guia Simulação </a>
<br> <a href="toolbar.html"> A guia Barra de Ferramentas </a>
<br> <a href="mouse.html"> O guia Mouse </a>
</blockquote>
<p> Na parte inferior da janela está o botão para restaurar ao modelo
do gabarito. Quando clicado, todas as opções e alterações nos atributos de ferramenta
voltarão às definições do gabarito atual (tal como selecionado no âmbito das
<a href="../prefs/"> preferências da aplicação </a >).
</p>
<p><strong>Próximo:</strong> <a href="canvas.html">A guia Área de Desenho (Canvas)</a>.</p>
</body>
</html>

122
doc/pt/html/guide/opts/mouse.html
View File

@ -1,61 +1,61 @@
<html>
<head>
<title>A guia Mouse</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Mouse</h1>
<p> Por padrão, quando você clicar com o mouse na área de desenho do Logisim,
a ferramenta selecionada no momento será utilizada. Se você clicar com o botão
direito ou <i>control-click</i>, ele irá exibir um menu <i>pop-up</i> para o componente
sob o mouse.
</p>
<p> O Logisim lhe permite modificar esse comportamento, aliviando-lhe a
necessidade de ir à barra de ferramentas e/ou ao explorador o tempo todo.
(Isto também poderá ser útil se você for canhoto). Cada combinação de um
botão do mouse e uma tecla modificadora (qualquer subconjunto de setas para deslocamento,
<i>control</i> e <i>alt</i>) poderá ser mapeado para uma ferramenta diferente.
A guia do mouse lhe permitirá configurar esses mapeamentos.
</p>
<center> <img src="mouse.png" width="393" height="324"> </center>
<ul>
<li> No lado esquerdo está um explorador, onde você poderá escolher a ferramenta
que desejar mapear.
</p> </li>
<li> No lado superior direito está um retângulo no qual você pode clicar
usando a combinação do mouse. Por exemplo, se você pretende criar novas conexões,
arrastando-as, em seguida, você deverá primeiro selecionar a ferramenta Conexões
(Wiring) no explorador (na biblioteca Base) e então fazer <i>shift-click</i> onde
estiver "Clicar usando uma combinação para mapear a ferramenta para conexão".
Se essa combinação já estiver sendo usada, o mapeamento logo em seguida será
substituído pela nova ferramenta.
</p> </li>
<li> <p> Abaixo desta área está uma lista dos mapeamentos correntes. Note-se que
todas as combinações que não estiverem listadas simplesmente usarão a ferramenta
selecionada.
</p> </li>
<li> <p> Mais abaixo está o botão Remover, por meio do qual você poderá excluir
o mapeamento que estiver atualmente selecionado na tabela acima dele. No
futuro, então, que essa combinação de mouse seria mapeada para qualquer ferramenta
que estiver selecionada na barra de ferramentas ou no painel de explorador.
</p> </li>
<li> <p> Por último está uma lista de atributos para a ferramenta selecionada
no momento na lista de mapeamentos. Cada ferramenta de mapeamento de mouse tem
seu próprio conjunto de atributos, diferentes daqueles utilizados no painel do
explorador e na barra de ferramentas. Você poderá editar os valores de atributo ali.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="../index.html"><em>Guia do usuário</em></a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia Mouse</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Mouse</h1>
<p> Por padrão, quando você clicar com o mouse na área de desenho do Logisim,
a ferramenta selecionada no momento será utilizada. Se você clicar com o botão
direito ou <i>control-click</i>, ele irá exibir um menu <i>pop-up</i> para o componente
sob o mouse.
</p>
<p> O Logisim lhe permite modificar esse comportamento, aliviando-lhe a
necessidade de ir à barra de ferramentas e/ou ao explorador o tempo todo.
(Isto também poderá ser útil se você for canhoto). Cada combinação de um
botão do mouse e uma tecla modificadora (qualquer subconjunto de setas para deslocamento,
<i>control</i> e <i>alt</i>) poderá ser mapeado para uma ferramenta diferente.
A guia do mouse lhe permitirá configurar esses mapeamentos.
</p>
<center> <img src="mouse.png" width="393" height="324"> </center>
<ul>
<li> No lado esquerdo está um explorador, onde você poderá escolher a ferramenta
que desejar mapear.
</p> </li>
<li> No lado superior direito está um retângulo no qual você pode clicar
usando a combinação do mouse. Por exemplo, se você pretende criar novas conexões,
arrastando-as, em seguida, você deverá primeiro selecionar a ferramenta Conexões
(Wiring) no explorador (na biblioteca Base) e então fazer <i>shift-click</i> onde
estiver "Clicar usando uma combinação para mapear a ferramenta para conexão".
Se essa combinação já estiver sendo usada, o mapeamento logo em seguida será
substituído pela nova ferramenta.
</p> </li>
<li> <p> Abaixo desta área está uma lista dos mapeamentos correntes. Note-se que
todas as combinações que não estiverem listadas simplesmente usarão a ferramenta
selecionada.
</p> </li>
<li> <p> Mais abaixo está o botão Remover, por meio do qual você poderá excluir
o mapeamento que estiver atualmente selecionado na tabela acima dele. No
futuro, então, que essa combinação de mouse seria mapeada para qualquer ferramenta
que estiver selecionada na barra de ferramentas ou no painel de explorador.
</p> </li>
<li> <p> Por último está uma lista de atributos para a ferramenta selecionada
no momento na lista de mapeamentos. Cada ferramenta de mapeamento de mouse tem
seu próprio conjunto de atributos, diferentes daqueles utilizados no painel do
explorador e na barra de ferramentas. Você poderá editar os valores de atributo ali.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="../index.html"><em>Guia do usuário</em></a></em>.</p>
</body>
</html>

132
doc/pt/html/guide/opts/simulate.html
View File

@ -1,66 +1,66 @@
<html>
<head>
<title>A guia Simulação (Simulation)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Simulação (Simulation)</h1>
<p> A guia de simulação permite configurar o algoritmo usado para
simulação de circuitos. Esses parâmetros são aplicáveis a todos os circuitos
que estejam simulados na mesma janela, mesmo que os circuitos estejam em outras
bibliotecas carregadas pelo projeto.
</p>
<center><img src="simulate.png" width="393" height="324"></center>
<ul>
<li> As <strong> Iterações Até Oscilação </strong> serve para especificar
por quanto tempo deverá simular um circuito antes de decidir que é oscilante.
O número representa a quantidade de cliques no relógio interno oculto
(um porta simples, leva apenas um clique). O valor padrão 1000 é suficiente para
quase todos os fins, inclusive para os circuitos de grande porte. Mas você
poderá aumentar o número de iterações, caso estiver trabalhando com um
circuito onde o Logisim reporte oscilações falsas. É pouco provável que isso seja
um problema na prática; uma dessas circunstâncias é a de um circuito que incorpora
muitos <i>latches</i> que podem travar quando a opção ruído aleatório é habilitada.
Você poderá querer diminuir o número de iterações, se estiver trabalhando com um
circuito que é propenso a oscilar e estiver usando um processador extremamente lento.
</p> </li>
<li> A <strong> Saída da Porta Quando Indefinida </strong> serve para configurar
como as portas lógicas internas se comportarão quando algumas entradas não estiverem
ligadas ou forem flutuantes. Por padrão, o Logisim ignora tais entradas, permitindo
uma porta trabalhar sobre menos entradas do que aquelas para as quais foi projetado.
No entanto, na vida real, uma porta irá se comportar imprevisivelmente em tal situação,
e por isso esse menu <i>drop-down</i> permitirá que se mudem as portas para tratar
as entradas desconectadas como erros.
</p> </li>
<li> O <strong> Adicionar Ruído Aos Atrasos de Componente </strong>
permitirá ativar ou desativar o ruído aleatório a ser adicionado aos
atrasos de componentes. A simulação interna usa um relógio oculto para
sua simulação, e para fornecer maior verossimilhança, cada
componente (excluindo conexões e distribuidores) tem um atraso entre o momento em que
recebe uma entrada e quando ele emitirá uma saída. Se esta opção for
habilitada, o Logisim ocasionalmente (uma vez a cada 16
reações do componente) fará com que ele tenha um clique a mais que
normal. Essa aleatoriedade é adicionada especificamente para se lidar com a trava
circuito (conforme abaixo): sem o ruído aleatório, o circuito oscila,
uma vez que as duas portas vão trabalhar em sintonia, mas com ruído aleatório
acrescentado, um porta finalmente ultrapassará a outra.
</p>
<center> <img src="latch.png" width="170" height="111"> </center>
<p> Recomendo manter essa opção, já que esta técnica implica na introdução de
erros raros em circuitos normais.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <a href="toolbar.html">A guia Barra de Ferramentas (Toolbar)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia Simulação (Simulation)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Simulação (Simulation)</h1>
<p> A guia de simulação permite configurar o algoritmo usado para
simulação de circuitos. Esses parâmetros são aplicáveis a todos os circuitos
que estejam simulados na mesma janela, mesmo que os circuitos estejam em outras
bibliotecas carregadas pelo projeto.
</p>
<center><img src="simulate.png" width="393" height="324"></center>
<ul>
<li> As <strong> Iterações Até Oscilação </strong> serve para especificar
por quanto tempo deverá simular um circuito antes de decidir que é oscilante.
O número representa a quantidade de cliques no relógio interno oculto
(um porta simples, leva apenas um clique). O valor padrão 1000 é suficiente para
quase todos os fins, inclusive para os circuitos de grande porte. Mas você
poderá aumentar o número de iterações, caso estiver trabalhando com um
circuito onde o Logisim reporte oscilações falsas. É pouco provável que isso seja
um problema na prática; uma dessas circunstâncias é a de um circuito que incorpora
muitos <i>latches</i> que podem travar quando a opção ruído aleatório é habilitada.
Você poderá querer diminuir o número de iterações, se estiver trabalhando com um
circuito que é propenso a oscilar e estiver usando um processador extremamente lento.
</p> </li>
<li> A <strong> Saída da Porta Quando Indefinida </strong> serve para configurar
como as portas lógicas internas se comportarão quando algumas entradas não estiverem
ligadas ou forem flutuantes. Por padrão, o Logisim ignora tais entradas, permitindo
uma porta trabalhar sobre menos entradas do que aquelas para as quais foi projetado.
No entanto, na vida real, uma porta irá se comportar imprevisivelmente em tal situação,
e por isso esse menu <i>drop-down</i> permitirá que se mudem as portas para tratar
as entradas desconectadas como erros.
</p> </li>
<li> O <strong> Adicionar Ruído Aos Atrasos de Componente </strong>
permitirá ativar ou desativar o ruído aleatório a ser adicionado aos
atrasos de componentes. A simulação interna usa um relógio oculto para
sua simulação, e para fornecer maior verossimilhança, cada
componente (excluindo conexões e distribuidores) tem um atraso entre o momento em que
recebe uma entrada e quando ele emitirá uma saída. Se esta opção for
habilitada, o Logisim ocasionalmente (uma vez a cada 16
reações do componente) fará com que ele tenha um clique a mais que
normal. Essa aleatoriedade é adicionada especificamente para se lidar com a trava
circuito (conforme abaixo): sem o ruído aleatório, o circuito oscila,
uma vez que as duas portas vão trabalhar em sintonia, mas com ruído aleatório
acrescentado, um porta finalmente ultrapassará a outra.
</p>
<center> <img src="latch.png" width="170" height="111"> </center>
<p> Recomendo manter essa opção, já que esta técnica implica na introdução de
erros raros em circuitos normais.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <a href="toolbar.html">A guia Barra de Ferramentas (Toolbar)</a>.</p>
</body>
</html>

120
doc/pt/html/guide/opts/toolbar.html
View File

@ -1,60 +1,60 @@
<html>
<head>
<title>A guia Barra de Tarefas (Toolbar)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Barra de Tarefas (Toolbar)</h1>
<p> Essa guia lhe permitirá configurar que ferramentas devem aparecer na
a barra de ferramentas.
</p>
<center> <img src="toolbar.png" width="393" height="324"> </center>
<p> No lado esquerdo fica um explorador, listando todas as ferramentas disponíveis,
e do lado direito localiza-se o conteúdo atual da barra de ferramentas.
("---" Três traços indicam um <em> separador </em>, que é desenhada com uma linha cinza).
Entre o explorador e a lista estão cinco botões e as opções:
</p>
<ul>
<li> <strong> Adicionar Ferramenta </strong> serve para acrescentar a ferramenta
selecionada ao explorador à esquerda, ao seu final.
</p> </li>
<li> <strong> Adicionar Separador </strong> serve para adicionar um separador
ao final da barra de ferramentas.
</p> </li>
<li> <strong> Mover Para Cima </strong> serve para mover o item selecionado
da barra para cima/esquerda uma posição.
</p> </li>
<li> <strong> Mover Para Baixo </strong> serve para mover o item selecionado
da barra de baixo/direita uma posição.
</p> </li>
<li> <strong> Remover </strong> serve para apagar o item selecionado
da barra de ferramentas.
</p> </li>
<li> <strong> Localização </strong> serve para configurar a posição da
barra de ferramentas na janela global. A barra de ferramentas pode ser colocada
em qualquer uma das quatro bordas da janela, descritas como norte, sul,
leste e oeste. Também pode ficar oculta, ou poderá ser colocada "abaixo do
centro" - isto é, à esquerda da tela, mas à direita do painel do explorador
e a tabela de atributos.
</p> </li>
</ul>
<p> Os atributos associados às ferramentas não serão exibidas nessa janela,
em vez disso, você poderá visualizá-las e editá-las no âmbito da janela principal.
</p>
<p><strong>Próximo:</strong> <a href="mouse.html">A guia Mouse</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia Barra de Tarefas (Toolbar)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Barra de Tarefas (Toolbar)</h1>
<p> Essa guia lhe permitirá configurar que ferramentas devem aparecer na
a barra de ferramentas.
</p>
<center> <img src="toolbar.png" width="393" height="324"> </center>
<p> No lado esquerdo fica um explorador, listando todas as ferramentas disponíveis,
e do lado direito localiza-se o conteúdo atual da barra de ferramentas.
("---" Três traços indicam um <em> separador </em>, que é desenhada com uma linha cinza).
Entre o explorador e a lista estão cinco botões e as opções:
</p>
<ul>
<li> <strong> Adicionar Ferramenta </strong> serve para acrescentar a ferramenta
selecionada ao explorador à esquerda, ao seu final.
</p> </li>
<li> <strong> Adicionar Separador </strong> serve para adicionar um separador
ao final da barra de ferramentas.
</p> </li>
<li> <strong> Mover Para Cima </strong> serve para mover o item selecionado
da barra para cima/esquerda uma posição.
</p> </li>
<li> <strong> Mover Para Baixo </strong> serve para mover o item selecionado
da barra de baixo/direita uma posição.
</p> </li>
<li> <strong> Remover </strong> serve para apagar o item selecionado
da barra de ferramentas.
</p> </li>
<li> <strong> Localização </strong> serve para configurar a posição da
barra de ferramentas na janela global. A barra de ferramentas pode ser colocada
em qualquer uma das quatro bordas da janela, descritas como norte, sul,
leste e oeste. Também pode ficar oculta, ou poderá ser colocada "abaixo do
centro" - isto é, à esquerda da tela, mas à direita do painel do explorador
e a tabela de atributos.
</p> </li>
</ul>
<p> Os atributos associados às ferramentas não serão exibidas nessa janela,
em vez disso, você poderá visualizá-las e editá-las no âmbito da janela principal.
</p>
<p><strong>Próximo:</strong> <a href="mouse.html">A guia Mouse</a>.</p>
</body>
</html>

156
doc/pt/html/guide/prefs/cmdline.html
View File

@ -1,78 +1,78 @@
<html>
<head>
<title>Opções para a linha de comandos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Opções para a linha de comandos</h1>
<p> Você poderá configurar as preferências do Logisim através de opções da linha
de comando. Isso pode ser particularmente útil em um laboratório de
computadores onde você queira que o Logisim inicie sempre da mesma forma
para todos os alunos, independente da forma como tenham sido usados
e configurados anteriormente.
</p>
<p> A sintaxe de linha de comando-geral é a seguinte.
<PRE>
java-jar <em> jarFileName <b> </b> </em> <em> [opções] </em> <em> [nomes] </em>
</Pre> </blockquote>
Os arquivos adicionais cujos nomes estiverem chamados na linha de comando serão
abertos em janelas separadas dentro do Logisim.
</p>
<p> O exemplo a seguir iniciará Logisim em sua configuração básica.
<PRE>
java-jar <em> jarFileName <b> </b> </em> -plain -gates shaped -locale en
</Pre> </blockquote> </p>
<p> As opções oferecidas incluem:
<dl>
<dt> <tt>-plain </tt> </dt>
<dt> <tt>-empty </tt> </dt>
<b> <dt> <tt>-template<em> templateFile </em> </b> </tt> </dt>
<dd> <p> E servem para configurar o gabarito para o Logisim usar.
</p> </dd>
<dt> <em> <tt>-gates [<b> shaped </b> | rectangular <b> </b>] </em> </tt> </dt>
<dd> <p> Serve para configura que tipo de portas será usado.
</p> </dd>
<b> <em> <dt> <tt> locale LocaleIdentifier </b> </em> </tt> </dt>
<dd> <p> Serve para configurar o idioma para o uso. Assim como este documento, os
idiomas disponíveis são: </p>
<center> <table>
<tr> <td> <tt> en </tt> Inglês </td> </tr>
<tr> <td> <tt> es </tt> Espanhol </td> </tr>
<tr> <td> <tt> pt </tt> Português (Brasil) </td> </tr>
<tr> <td> <tt> ru </tt> Russo <td> </td> </tr>
</table> </center> </dd>
<dt> <tt>-accents <em> [<b> yes </b> | <b> no </b>] </em> </tt> </dt>
<dd> <p> Esse é apenas relevante para as línguas que usam caracteres
fora do conjunto de caracteres ASCII de 7 bits, o que inclui
idiomas com caracteres acentuados, e não seria o caso do Inglês.
Se <em>no</em>, os caracteres fora do conjunto de caracteres ASCII de 7 bits
serão substituídos por equivalentes adequados à linguagem;
isso seria útil para as combinações Java/SO onde esses caracteres também
não forem disponíveis.
</p> </dd>
<dt> <tt>-nosplash </tt> </dt>
<dd> <p> Serve para ocultar a tela de apresentação inicial do Logisim.
</p> </dd>
<dt> <tt>-help </tt> </dt>
<dd> <p> Serve para exibir um resumo das opções de linha de comando.
</p> </dd>
<dt> <tt>-version </tt> </dt>
<dd> <p> Serve para exibir o número da versão do Logisim. </p> </dd>
</dl></p>
<p><strong>Next:</strong> <em><a href="../index.html">User's Guide</a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Opções para a linha de comandos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Opções para a linha de comandos</h1>
<p> Você poderá configurar as preferências do Logisim através de opções da linha
de comando. Isso pode ser particularmente útil em um laboratório de
computadores onde você queira que o Logisim inicie sempre da mesma forma
para todos os alunos, independente da forma como tenham sido usados
e configurados anteriormente.
</p>
<p> A sintaxe de linha de comando-geral é a seguinte.
<PRE>
java-jar <em> jarFileName <b> </b> </em> <em> [opções] </em> <em> [nomes] </em>
</Pre> </blockquote>
Os arquivos adicionais cujos nomes estiverem chamados na linha de comando serão
abertos em janelas separadas dentro do Logisim.
</p>
<p> O exemplo a seguir iniciará Logisim em sua configuração básica.
<PRE>
java-jar <em> jarFileName <b> </b> </em> -plain -gates shaped -locale en
</Pre> </blockquote> </p>
<p> As opções oferecidas incluem:
<dl>
<dt> <tt>-plain </tt> </dt>
<dt> <tt>-empty </tt> </dt>
<b> <dt> <tt>-template<em> templateFile </em> </b> </tt> </dt>
<dd> <p> E servem para configurar o gabarito para o Logisim usar.
</p> </dd>
<dt> <em> <tt>-gates [<b> shaped </b> | rectangular <b> </b>] </em> </tt> </dt>
<dd> <p> Serve para configura que tipo de portas será usado.
</p> </dd>
<b> <em> <dt> <tt> locale LocaleIdentifier </b> </em> </tt> </dt>
<dd> <p> Serve para configurar o idioma para o uso. Assim como este documento, os
idiomas disponíveis são: </p>
<center> <table>
<tr> <td> <tt> en </tt> Inglês </td> </tr>
<tr> <td> <tt> es </tt> Espanhol </td> </tr>
<tr> <td> <tt> pt </tt> Português (Brasil) </td> </tr>
<tr> <td> <tt> ru </tt> Russo <td> </td> </tr>
</table> </center> </dd>
<dt> <tt>-accents <em> [<b> yes </b> | <b> no </b>] </em> </tt> </dt>
<dd> <p> Esse é apenas relevante para as línguas que usam caracteres
fora do conjunto de caracteres ASCII de 7 bits, o que inclui
idiomas com caracteres acentuados, e não seria o caso do Inglês.
Se <em>no</em>, os caracteres fora do conjunto de caracteres ASCII de 7 bits
serão substituídos por equivalentes adequados à linguagem;
isso seria útil para as combinações Java/SO onde esses caracteres também
não forem disponíveis.
</p> </dd>
<dt> <tt>-nosplash </tt> </dt>
<dd> <p> Serve para ocultar a tela de apresentação inicial do Logisim.
</p> </dd>
<dt> <tt>-help </tt> </dt>
<dd> <p> Serve para exibir um resumo das opções de linha de comando.
</p> </dd>
<dt> <tt>-version </tt> </dt>
<dd> <p> Serve para exibir o número da versão do Logisim. </p> </dd>
</dl></p>
<p><strong>Next:</strong> <em><a href="../index.html">User's Guide</a></em>.</p>
</body>
</html>

64
doc/pt/html/guide/prefs/exp.html
View File

@ -1,32 +1,32 @@
<html>
<head>
<title>A guia Experimental</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Experimental</h1>
<center><img src="exp.png" width="360" height="233"></center>
<p> Essas preferências servem para habilitar recursos considerados experimentais,
inseridos com o intuito de receber retorno dos usuários.
</p>
<ul>
<li> <b> Aceleração gráfica: </b> Vários usuários relataram que o
Logisim parece bastante lento na renderização gráfica. Um usuário notou
que a adição de <tt>-Dsun.java2d.d3d = true </tt> na linha de comando pareceu
resolver isso. Você poderá tentar controlar isso usando um
menu <i>drop-down</i>. Eu mesmo não observei tais problemas com a velocidade
em Logisim, por isso não posso avaliar a sua eficácia; confiarei nos relatórios
dos usuários sobre se isso servirá como ajuda. Notar certamente não terá
qualquer efeito até o Logisim seja reiniciado.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="cmdline.html">Opções da linha de comando</a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia Experimental</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Experimental</h1>
<center><img src="exp.png" width="360" height="233"></center>
<p> Essas preferências servem para habilitar recursos considerados experimentais,
inseridos com o intuito de receber retorno dos usuários.
</p>
<ul>
<li> <b> Aceleração gráfica: </b> Vários usuários relataram que o
Logisim parece bastante lento na renderização gráfica. Um usuário notou
que a adição de <tt>-Dsun.java2d.d3d = true </tt> na linha de comando pareceu
resolver isso. Você poderá tentar controlar isso usando um
menu <i>drop-down</i>. Eu mesmo não observei tais problemas com a velocidade
em Logisim, por isso não posso avaliar a sua eficácia; confiarei nos relatórios
dos usuários sobre se isso servirá como ajuda. Notar certamente não terá
qualquer efeito até o Logisim seja reiniciado.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="cmdline.html">Opções da linha de comando</a></em>.</p>
</body>
</html>

70
doc/pt/html/guide/prefs/index.html
View File

@ -1,35 +1,35 @@
<html>
<head>
<title>Preferências da aplicação</title>
</head>
<body bgcolor="FFFFFF">
<h1>Preferências da aplicação</h1>
<p> Logisim oferece dois tipos de opções para configuração:
<em> preferências para aplicação </em> e <em> opções para projeto </em>.
As preferências para a aplicação abrangem todas os projetos abertos,
enquanto as opções para projeto são específicas para um projeto apenas.
Esta seção apresentará as preferências para a aplicação;
<a href="../opts/"> opções para projeto </a> serão descritas em outra
seção.
</p>
<p> Você poderá visualizar e editar as preferências para a aplicação através de
Preferências ... opção no menu Arquivo (File) (ou, no Mac OS, no menu do Logisim),
que fará aparecer uma janela com várias guias. Apresentaremos essas guias
separadamente, e então veremos como as preferências poderão ser configuradas
a partir da linha de comando.
</p>
<blockquote>
<a href="template.html"> A guia Modelo </a>
<br> <a href="tools.html"> A guia Ferramentas </a>
<br> <a href="intl.html"> O guia Internacional </a>
<br> <a href="exp.html"> A guia Experimental </a>
<br> <a href="cmdline.html"> A linha de comando </a>
</blockquote>
<p><strong>Próximo:</strong> <a href="template.html">A guia Gabarito (Template)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Preferências da aplicação</title>
</head>
<body bgcolor="FFFFFF">
<h1>Preferências da aplicação</h1>
<p> Logisim oferece dois tipos de opções para configuração:
<em> preferências para aplicação </em> e <em> opções para projeto </em>.
As preferências para a aplicação abrangem todas os projetos abertos,
enquanto as opções para projeto são específicas para um projeto apenas.
Esta seção apresentará as preferências para a aplicação;
<a href="../opts/"> opções para projeto </a> serão descritas em outra
seção.
</p>
<p> Você poderá visualizar e editar as preferências para a aplicação através de
Preferências ... opção no menu Arquivo (File) (ou, no Mac OS, no menu do Logisim),
que fará aparecer uma janela com várias guias. Apresentaremos essas guias
separadamente, e então veremos como as preferências poderão ser configuradas
a partir da linha de comando.
</p>
<blockquote>
<a href="template.html"> A guia Modelo </a>
<br> <a href="tools.html"> A guia Ferramentas </a>
<br> <a href="intl.html"> O guia Internacional </a>
<br> <a href="exp.html"> A guia Experimental </a>
<br> <a href="cmdline.html"> A linha de comando </a>
</blockquote>
<p><strong>Próximo:</strong> <a href="template.html">A guia Gabarito (Template)</a>.</p>
</body>
</html>

174
doc/pt/html/guide/prefs/intl.html
View File

@ -1,87 +1,87 @@
<html>
<head>
<title>A guia International</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia International</h1>
<center><img src="intl.png" width="328" height="224"></center>
<p> Essas preferências oferecem opções que permite ao Logisim ser usado em muitos
outros países. A guia inclui três opções.
</p>
<ul>
<li> <b> Forma da porta (Gate Shape): </b> o Logisim oferece três padrões para portas:
<em>shaped</em>, <em>rectangular</em>, e <em> DIN 40700 </em>.
A tabela a seguir ilustrará a distinção.
</p>
<center> <img src="gates.png" width="412" height="176"> </center>
<p> O estilo <i>shaped</i> tende a ser mais popular nos EUA, enquanto o estilo
<i>rectangular</i> tende a ser mais popular na Europa, algumas pessoas se referem ao
esses estilos de acordo com essas regiões, por isso os termos neutros
<em> shaped </em> e <em> rectangular </em> tem sido os preferidos.
A norma DIN 40700 foi um padrão para a elaboração de componentes electrônicos
digitais e analógicos, adotada pela DIN, uma organização para padrões alemães.
A DIN adotou a norma retangular para componentes digitais em 1976, mas alguns
os engenheiros continuam a usar o estilo mais antigo, mas isso parece ser
cada vez mais raro.
</p>
<p> O Logisim não segue estritamente nenhuma norma, ele procura usar um meio
termo para permitir alternância entre eles. Em particular, as portas em formato
convencional são mais quadradas que as dimensões definidas pelos relevantes
padrões IEEE. E, apesar das portas XOR e XNOR devessem ser da mesma
largura, assim como as portas OR e NOR fossem mais retangulares, elas não o são
devido a dificuldades na compactação da porta XOR convencional.
</p> </li>
<li> <b> Idioma: </b>
Alternar entre idiomas. A versão atual é fornecida para os idiomas
inglês, espanhol, russo, alemão e português.
</p>
<ul>
<li> A tradução para o <b> alemão </b> foi introduzida na versão 2.6.1 do Logisim e
continua atual. Feita por Uwe Zimmermann, um membro do corpo docente da Universidade
de Uppsala, na Suécia.
</li>
<li> A tradução para o <b> russo </b> foi introduzida na versão 2.4.0 do Logisim
e continua atual. Feita por Ilia Lilov, da Rússia. </li>
<li> A tradução para o <b> espanhol </b> estava completa na versão 2.1.0 do Logisim,
mas versões posteriores Logisim acrescentaram novas opções que permanecem sem tradução.
A contribuição foi feita por Pablo Leal Ramos, da Espanha.
</li>
</ul>
<p> Traduções do Logisim para outras línguas são bem-vindas! Se você
estiver interessado, contacte-me, Carl Burch. Isso não será um compromisso.
Ficarei feliz em ouvir de seu interesse, e eu lhe direi
se souber de alguém que já esteja lidando com isso;
prepararei uma versão para você trabalhar, e lhe enviarei instruções.
O processo de tradução não requer uma compreensão de Java.
</p> </li>
<li> <b> Substituir caracteres acentuados: </b>
Algumas plataformas têm pouco apoio para caracteres (como
&ntilde; ou &ouml;), que não aparecem dentre os caracteres ASCII de 7 bits.
Quando isso for verificado, o Logisim irá substituir todas as instâncias da
caracteres com o equivalente adequado em caracteres ASCII de 7 bits.
A opção estará desativada quando o idioma corrente não contiver
qualquer equivalente disponível (como em inglês).
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="exp.html">A guia Experimental</a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia International</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia International</h1>
<center><img src="intl.png" width="328" height="224"></center>
<p> Essas preferências oferecem opções que permite ao Logisim ser usado em muitos
outros países. A guia inclui três opções.
</p>
<ul>
<li> <b> Forma da porta (Gate Shape): </b> o Logisim oferece três padrões para portas:
<em>shaped</em>, <em>rectangular</em>, e <em> DIN 40700 </em>.
A tabela a seguir ilustrará a distinção.
</p>
<center> <img src="gates.png" width="412" height="176"> </center>
<p> O estilo <i>shaped</i> tende a ser mais popular nos EUA, enquanto o estilo
<i>rectangular</i> tende a ser mais popular na Europa, algumas pessoas se referem ao
esses estilos de acordo com essas regiões, por isso os termos neutros
<em> shaped </em> e <em> rectangular </em> tem sido os preferidos.
A norma DIN 40700 foi um padrão para a elaboração de componentes electrônicos
digitais e analógicos, adotada pela DIN, uma organização para padrões alemães.
A DIN adotou a norma retangular para componentes digitais em 1976, mas alguns
os engenheiros continuam a usar o estilo mais antigo, mas isso parece ser
cada vez mais raro.
</p>
<p> O Logisim não segue estritamente nenhuma norma, ele procura usar um meio
termo para permitir alternância entre eles. Em particular, as portas em formato
convencional são mais quadradas que as dimensões definidas pelos relevantes
padrões IEEE. E, apesar das portas XOR e XNOR devessem ser da mesma
largura, assim como as portas OR e NOR fossem mais retangulares, elas não o são
devido a dificuldades na compactação da porta XOR convencional.
</p> </li>
<li> <b> Idioma: </b>
Alternar entre idiomas. A versão atual é fornecida para os idiomas
inglês, espanhol, russo, alemão e português.
</p>
<ul>
<li> A tradução para o <b> alemão </b> foi introduzida na versão 2.6.1 do Logisim e
continua atual. Feita por Uwe Zimmermann, um membro do corpo docente da Universidade
de Uppsala, na Suécia.
</li>
<li> A tradução para o <b> russo </b> foi introduzida na versão 2.4.0 do Logisim
e continua atual. Feita por Ilia Lilov, da Rússia. </li>
<li> A tradução para o <b> espanhol </b> estava completa na versão 2.1.0 do Logisim,
mas versões posteriores Logisim acrescentaram novas opções que permanecem sem tradução.
A contribuição foi feita por Pablo Leal Ramos, da Espanha.
</li>
</ul>
<p> Traduções do Logisim para outras línguas são bem-vindas! Se você
estiver interessado, contacte-me, Carl Burch. Isso não será um compromisso.
Ficarei feliz em ouvir de seu interesse, e eu lhe direi
se souber de alguém que já esteja lidando com isso;
prepararei uma versão para você trabalhar, e lhe enviarei instruções.
O processo de tradução não requer uma compreensão de Java.
</p> </li>
<li> <b> Substituir caracteres acentuados: </b>
Algumas plataformas têm pouco apoio para caracteres (como
&ntilde; ou &ouml;), que não aparecem dentre os caracteres ASCII de 7 bits.
Quando isso for verificado, o Logisim irá substituir todas as instâncias da
caracteres com o equivalente adequado em caracteres ASCII de 7 bits.
A opção estará desativada quando o idioma corrente não contiver
qualquer equivalente disponível (como em inglês).
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="exp.html">A guia Experimental</a></em>.</p>
</body>
</html>

78
doc/pt/html/guide/prefs/template.html
View File

@ -1,39 +1,39 @@
<html>
<head>
<title>A guia Gabarito</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Gabarito</h1>
<center><img src="template.png" width="360" height="233"></center>
<p> Um <em> gabarito </em> é um arquivo do Logisim que será usado como ponto de partida
quando esse criar um novo projeto. Além disso, se você tiver um
arquivo Logisim com um ambiente particularmente configurado, você
poderá "redefinir" esse ambiente, utilizando o botão para restaurar o modelo
na janela de edição das opções de projeto.
</p>
<p> Embora os gabaritos sejam úteis em outras situações também, eles são
particularmente adequados para uso em sala de aula, onde um instrutor queira
distribuir um modelo para os alunos começarem a trabalhar a partir dele. Isso é
particularmente provável se a turma já usar o Logisim intensivamente, incluindo
muitos dos recursos mais avançados, caso em que o padrão simples
de configuração pode ser simples demais. Os gabaritos também podem ser úteis em
sala de aula quando o professor quiser abrir um arquivo enviado por
um aluno que tenha configurado o ambiente de forma mais significativa.
</p>
<p> Por padrão, a opção "Plain Template" estará selecionada,
utilizando o modelo padrão que acompanha o Logisim. Se você quiser um
configuração mais limpa, você poderá escolher um "gabarito vazio".
Mas se você quiser designar um outro arquivo para usar como modelo,
selecione-o através do botão Selecionar (Select)... e, em seguida, escolha o
a opção "Gabarito personalizado" opção.
</p>
<p><strong>Próximo:</strong> <a href="tools.html">A guia Ferramentas (Tools)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia Gabarito</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Gabarito</h1>
<center><img src="template.png" width="360" height="233"></center>
<p> Um <em> gabarito </em> é um arquivo do Logisim que será usado como ponto de partida
quando esse criar um novo projeto. Além disso, se você tiver um
arquivo Logisim com um ambiente particularmente configurado, você
poderá "redefinir" esse ambiente, utilizando o botão para restaurar o modelo
na janela de edição das opções de projeto.
</p>
<p> Embora os gabaritos sejam úteis em outras situações também, eles são
particularmente adequados para uso em sala de aula, onde um instrutor queira
distribuir um modelo para os alunos começarem a trabalhar a partir dele. Isso é
particularmente provável se a turma já usar o Logisim intensivamente, incluindo
muitos dos recursos mais avançados, caso em que o padrão simples
de configuração pode ser simples demais. Os gabaritos também podem ser úteis em
sala de aula quando o professor quiser abrir um arquivo enviado por
um aluno que tenha configurado o ambiente de forma mais significativa.
</p>
<p> Por padrão, a opção "Plain Template" estará selecionada,
utilizando o modelo padrão que acompanha o Logisim. Se você quiser um
configuração mais limpa, você poderá escolher um "gabarito vazio".
Mas se você quiser designar um outro arquivo para usar como modelo,
selecione-o através do botão Selecionar (Select)... e, em seguida, escolha o
a opção "Gabarito personalizado" opção.
</p>
<p><strong>Próximo:</strong> <a href="tools.html">A guia Ferramentas (Tools)</a>.</p>
</body>
</html>

80
doc/pt/html/guide/prefs/tools.html
View File

@ -1,40 +1,40 @@
<html>
<head>
<title>A guia Ferramentas (Tools)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Ferramentas (Tools)</h1>
<center><img src="tools.png" width="360" height="233"></center>
<p> Essa guia inclui opções que afetam a forma como as ferramentas predefinidas
se comportam.
</p>
<ul>
<li> <b> Após adicionar componentes: </b> Por padrão, após a adição de cada componente
individal, o Logisim volta para a ferramenta Editar para permitir que você mova
componentes de lugar e para adicionar conexões. Essa opção lhe permitirá configurar esse
comportamento para que o Logisim permaneça na mesma ferramenta para adições do mesmo
componente, até optar por escolher a ferramenta Editar novamente. (Esse foi o
comportamento padrão antes da versão 2.3.0. Embora mais intuitivo, esse comportamento
requer mais movimentos do mouse para alternar entre ferramentas.)
</p> </li>
<li> <b> Mostrar contornos durante acréscimos: </b> Quando marcado, ou quando uma
ferramenta para adicionar um novo componente for selecionada, um contorno cinza-claro
do componente a ser adicionado será desenhado a medida que o mouse se mover pela tela.
Por exemplo, se você selecionar a ferramenta porta AND e mover o mouse pela janela
(sem pressionar o botão do mouse), um contorno cinza de um porta AND será exibido
onde o cursor estiver e aparecerá quando o mouse for clicado.
Se desmarcar a opção, irá desativar esse comportamento.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="intl.html">A guia International</a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>A guia Ferramentas (Tools)</title>
</head>
<body bgcolor="FFFFFF">
<h1>A guia Ferramentas (Tools)</h1>
<center><img src="tools.png" width="360" height="233"></center>
<p> Essa guia inclui opções que afetam a forma como as ferramentas predefinidas
se comportam.
</p>
<ul>
<li> <b> Após adicionar componentes: </b> Por padrão, após a adição de cada componente
individal, o Logisim volta para a ferramenta Editar para permitir que você mova
componentes de lugar e para adicionar conexões. Essa opção lhe permitirá configurar esse
comportamento para que o Logisim permaneça na mesma ferramenta para adições do mesmo
componente, até optar por escolher a ferramenta Editar novamente. (Esse foi o
comportamento padrão antes da versão 2.3.0. Embora mais intuitivo, esse comportamento
requer mais movimentos do mouse para alternar entre ferramentas.)
</p> </li>
<li> <b> Mostrar contornos durante acréscimos: </b> Quando marcado, ou quando uma
ferramenta para adicionar um novo componente for selecionada, um contorno cinza-claro
do componente a ser adicionado será desenhado a medida que o mouse se mover pela tela.
Por exemplo, se você selecionar a ferramenta porta AND e mover o mouse pela janela
(sem pressionar o botão do mouse), um contorno cinza de um porta AND será exibido
onde o cursor estiver e aparecerá quando o mouse for clicado.
Se desmarcar a opção, irá desativar esse comportamento.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="intl.html">A guia International</a></em>.</p>
</body>
</html>

124
doc/pt/html/guide/prop/delays.html
View File

@ -1,62 +1,62 @@
<html>
<head>
<title>Atrasos em porta (Gate delays)</title>
</head>
<body bgcolor="FFFFFF">
<h1>Atrasos em porta (Gate delays)</h1>
<p> Como um exemplo do nível de sofisticação do algoritmo do Logisim,
considere o circuito a seguir.
</p>
<center> <img src="const0.png" width="171" height="55"> </center>
<p> "obviamente" sempre terá saídas em 0. Mas, na verdade, as portas não
reagem instantaneamente às suas entradas, e nem tampouco o Logisim.
Como resultado, quando as entradas nesse circuito variam de 0 para 1, a
porta AND brevemente verá duas entradas iguais a 1, e irá emitir um breve 1.
Você não vai vê-lo na tela. Mas esse efeito é perceptível quando se
utilizar a saída da porta AND como entrada de <i>clock</i> de um <i>flip-flop</i>
tipo D.
</p>
<center> <img src="using-const0.png" width="231" height="68"> </center>
<p> Se testar a entrada, variando de 0 para 1, isso levará a um valor instantâneo
igual a 1 que irá para o <i>flip-flop</i> tipo D e, portanto,
o valor do <i>flip-flop</i> irá alternar cada vez que o circuito de entrada
for de 0 para 1.
</p>
<p> Cada componente tem um atraso associado a ele. Componentes mais sofisticados
construídos em Logisim tendem a ter atrasos maiores, mas esses atrasos são um tanto
arbitrários e podem não refletir a realidade.
</p>
<p> Do ponto de vista técnico, é relativamente fácil lidar com
esse nível de sofisticação em um único circuito. Lidar com atrasos de porta
em subcircuitos, porém, é um pouco mais complexo; o Logisim tem a pretensão de
abordar isso corretamente, colocando todos os valores primitivos de propagação
do componente em uma programação única, independentemente do subcircuito em que o
componente se encontrar.
</p>
<p> (Via a opção <a href="../opts/index.html"> Opções de projeto </a> na janela
<a guia href="../opts/simulate.html"> Simulação</a>, você poderá configurar o Logisim
para adicionar um atraso aleatório, ocasional, para a propagação de um componente.
Isso tem o objetivo de simular a desigualdade de circuitos reais. Em particular, um
<i>latch</i> SR construído com duas portas NOR irá oscilar sem essa aleatoriedade,
já que ambas as portas irão processar suas entradas em sincronia. Essa aleatoriedade é
desabilitada por padrão.)
</p>
<p> Notar que pararei de dizer o Logisim sempre tratará bem atrasos de porta.
Mas pelo menos ele tentará.
</p>
<p><strong>Próximo:</strong> <a href="oscillate.html">Erros de oscilação</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Atrasos em porta (Gate delays)</title>
</head>
<body bgcolor="FFFFFF">
<h1>Atrasos em porta (Gate delays)</h1>
<p> Como um exemplo do nível de sofisticação do algoritmo do Logisim,
considere o circuito a seguir.
</p>
<center> <img src="const0.png" width="171" height="55"> </center>
<p> "obviamente" sempre terá saídas em 0. Mas, na verdade, as portas não
reagem instantaneamente às suas entradas, e nem tampouco o Logisim.
Como resultado, quando as entradas nesse circuito variam de 0 para 1, a
porta AND brevemente verá duas entradas iguais a 1, e irá emitir um breve 1.
Você não vai vê-lo na tela. Mas esse efeito é perceptível quando se
utilizar a saída da porta AND como entrada de <i>clock</i> de um <i>flip-flop</i>
tipo D.
</p>
<center> <img src="using-const0.png" width="231" height="68"> </center>
<p> Se testar a entrada, variando de 0 para 1, isso levará a um valor instantâneo
igual a 1 que irá para o <i>flip-flop</i> tipo D e, portanto,
o valor do <i>flip-flop</i> irá alternar cada vez que o circuito de entrada
for de 0 para 1.
</p>
<p> Cada componente tem um atraso associado a ele. Componentes mais sofisticados
construídos em Logisim tendem a ter atrasos maiores, mas esses atrasos são um tanto
arbitrários e podem não refletir a realidade.
</p>
<p> Do ponto de vista técnico, é relativamente fácil lidar com
esse nível de sofisticação em um único circuito. Lidar com atrasos de porta
em subcircuitos, porém, é um pouco mais complexo; o Logisim tem a pretensão de
abordar isso corretamente, colocando todos os valores primitivos de propagação
do componente em uma programação única, independentemente do subcircuito em que o
componente se encontrar.
</p>
<p> (Via a opção <a href="../opts/index.html"> Opções de projeto </a> na janela
<a guia href="../opts/simulate.html"> Simulação</a>, você poderá configurar o Logisim
para adicionar um atraso aleatório, ocasional, para a propagação de um componente.
Isso tem o objetivo de simular a desigualdade de circuitos reais. Em particular, um
<i>latch</i> SR construído com duas portas NOR irá oscilar sem essa aleatoriedade,
já que ambas as portas irão processar suas entradas em sincronia. Essa aleatoriedade é
desabilitada por padrão.)
</p>
<p> Notar que pararei de dizer o Logisim sempre tratará bem atrasos de porta.
Mas pelo menos ele tentará.
</p>
<p><strong>Próximo:</strong> <a href="oscillate.html">Erros de oscilação</a>.</p>
</body>
</html>

54
doc/pt/html/guide/prop/index.html
View File

@ -1,27 +1,27 @@
<html>
<head>
<title>Propagação de valor</title>
</head>
<body bgcolor="FFFFFF">
<h1>Propagação de valor</h1>
<p> O algoritmo do Logisim para simular a propagação de valores através
circuitos não é algo com que você normalmente precise se preocupar. Basta
dizer que o algoritmo é sofisticado o suficiente para dar conta dos atrasos
em portas, mas não é realista o bastante para lidar com fenômenos mais
complexos como variações de voltagens ou condições conflitantes.
</p>
<p> Você ainda quer saber mais?
<blockquote>
<a href="delays.html"> Atrasos de portas </a>
<br> <a href="oscillate.html"> Erros de oscilação </a>
<br> <a href="shortcome.html"> Deficiências </a>
</blockquote></p>
<p><strong>Próximo:</strong> <a href="delays.html">Atrasos de porta (Gate delays)</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Propagação de valor</title>
</head>
<body bgcolor="FFFFFF">
<h1>Propagação de valor</h1>
<p> O algoritmo do Logisim para simular a propagação de valores através
circuitos não é algo com que você normalmente precise se preocupar. Basta
dizer que o algoritmo é sofisticado o suficiente para dar conta dos atrasos
em portas, mas não é realista o bastante para lidar com fenômenos mais
complexos como variações de voltagens ou condições conflitantes.
</p>
<p> Você ainda quer saber mais?
<blockquote>
<a href="delays.html"> Atrasos de portas </a>
<br> <a href="oscillate.html"> Erros de oscilação </a>
<br> <a href="shortcome.html"> Deficiências </a>
</blockquote></p>
<p><strong>Próximo:</strong> <a href="delays.html">Atrasos de porta (Gate delays)</a>.</p>
</body>
</html>

110
doc/pt/html/guide/prop/oscillate.html
View File

@ -1,55 +1,55 @@
<html>
<head>
<title>Erros de oscilação</title>
</head>
<body bgcolor="FFFFFF">
<h1>Erros de oscilação</h1>
<p> O algoritmo de propagação, que normalmente trabalha silenciosamente, sem qualquer
problemas, vai se tornar mair visível quando você criar um circuito que oscile.
</p>
<center> <img src="oscillate-before.png" width="318" height="213"> </center>
<p> Esse circuito está em condição estável. Mas se você mudar a entrada para 1,
o circuito irá efetivamente entrar em um <i>loop</i> infinito.
Depois um tempo, o Logisim simplesmente desistirá e mostrará a mensagem
"oscilação aparente" dizendo que ele acredita que o circuito esteja oscilando.
</p>
<center> <img src="oscillate-error.png" width="318" height="213"> </center>
<p> Ele irá exibir os valores que tiver no momento em que desistir. Esses valores
parecerão errados - nessa tela, a porta AND estará emitindo 1
apesar de uma de suas entradas serem 0, mas poderia ser porque a porta NOT
tem uma entrada em 1 e uma saída em um 1.
</p>
<p> O Logisim prestativamente exibirá círculos em vermelho em cada local que
possa estar envolvido na oscilação. Se um ponto envolvido estiver em um
subcircuito, o Logisim irá colocar todo o contorno do subcircuito em vermelho.
</p>
<p> Quando Logisim detectar oscilação, ele desligará todas as simulações.
Você poderá reativar a simulação usando o menu Simulação e a opção Simulação Ativada.
</p>
<p> O Logisim detecta oscilações usando uma técnica bastante simples: se a
simulação dos circuitos aparecer em muitas iterações, então ele irá simplesmente
desistir e reportará oscilação. (Os pontos que identificar como envolvidos serão
aqueles que forem afetados nos últimos 25% do total das iterações.)
Assim, ele poderia erroneamente relatar oscilação, especialmente se você estiver
trabalhando com um circuito excepcionalmente grande, mas isso seria um bem maior
do que qualquer outro que eu já tenha construído com o Logisim.
Em qualquer caso, se você estiver confiante de que a mensagem seja um erro, você
poderá configurar o número de iterações concluídas antes da oscilação ocorra através
da janela <a href="../opts/index.html"> Opções de projeto </a> em
<a href="../opts/simulate.html"> Guia da simulação</a>.
</p>
<p><strong>Próximo:</strong> <a href="shortcome.html">Deficiências</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Erros de oscilação</title>
</head>
<body bgcolor="FFFFFF">
<h1>Erros de oscilação</h1>
<p> O algoritmo de propagação, que normalmente trabalha silenciosamente, sem qualquer
problemas, vai se tornar mair visível quando você criar um circuito que oscile.
</p>
<center> <img src="oscillate-before.png" width="318" height="213"> </center>
<p> Esse circuito está em condição estável. Mas se você mudar a entrada para 1,
o circuito irá efetivamente entrar em um <i>loop</i> infinito.
Depois um tempo, o Logisim simplesmente desistirá e mostrará a mensagem
"oscilação aparente" dizendo que ele acredita que o circuito esteja oscilando.
</p>
<center> <img src="oscillate-error.png" width="318" height="213"> </center>
<p> Ele irá exibir os valores que tiver no momento em que desistir. Esses valores
parecerão errados - nessa tela, a porta AND estará emitindo 1
apesar de uma de suas entradas serem 0, mas poderia ser porque a porta NOT
tem uma entrada em 1 e uma saída em um 1.
</p>
<p> O Logisim prestativamente exibirá círculos em vermelho em cada local que
possa estar envolvido na oscilação. Se um ponto envolvido estiver em um
subcircuito, o Logisim irá colocar todo o contorno do subcircuito em vermelho.
</p>
<p> Quando Logisim detectar oscilação, ele desligará todas as simulações.
Você poderá reativar a simulação usando o menu Simulação e a opção Simulação Ativada.
</p>
<p> O Logisim detecta oscilações usando uma técnica bastante simples: se a
simulação dos circuitos aparecer em muitas iterações, então ele irá simplesmente
desistir e reportará oscilação. (Os pontos que identificar como envolvidos serão
aqueles que forem afetados nos últimos 25% do total das iterações.)
Assim, ele poderia erroneamente relatar oscilação, especialmente se você estiver
trabalhando com um circuito excepcionalmente grande, mas isso seria um bem maior
do que qualquer outro que eu já tenha construído com o Logisim.
Em qualquer caso, se você estiver confiante de que a mensagem seja um erro, você
poderá configurar o número de iterações concluídas antes da oscilação ocorra através
da janela <a href="../opts/index.html"> Opções de projeto </a> em
<a href="../opts/simulate.html"> Guia da simulação</a>.
</p>
<p><strong>Próximo:</strong> <a href="shortcome.html">Deficiências</a>.</p>
</body>
</html>

114
doc/pt/html/guide/prop/shortcome.html
View File

@ -1,57 +1,57 @@
<html>
<head>
<title>Limitações</title>
</head>
<body bgcolor="FFFFFF">
<h1>Limitações</h1>
<p> O algoritmo de propagação do Logisim é sofisticado o suficiente
para quase todos os fins educativos, mas não é sofisticado o bastante
para o projeto de um circuito industrial. Em ordem das mais para as menos
contundentes, as deficiências da técnica de propagação do Logisim
incluem:
<ul>
<li> Exceto para os problemas de atrasos em portas, o Logisim não trata de forma
particular questões de temporização. É muito idealizada, de modo que um par de portas NOR
configuradas em um <i>latch</i> SR irá mudar em sincronia infinitamente, melhor
que, eventualmente, o circuito chegue a um estado permanente.
</p> </li>
<li> O Logisim não pode simular subcircuitos cujos pinos, às vezes, se comportem
como entradas e às vezes como saídas. Componentes criados usando Java poderão ter
tais pinos, como é o caso nas bibliotecas predefinidas, do circuito de memória da
biblioteca RAM que contém um pino D, que pode atuar tanto como entrada e como saída.
</p> </li>
<li> O Logisim suspenderá sua simulação após um número fixo de iterações
supondo haver um erro de oscilação.
É concebível, que em um grande circuito isso não se trate de problema que possa levar
à oscilação.
</p> </li>
<li> O Logisim não faz nada com relação à discriminação entre níveis de tensão:
Um bit poderá estar apenas ligado, desligado, não especificado, e em erro.
</p> </li>
<li> Há outras lacunas, também, que eu tenha omitido porque elas podem ser tão
obscuras que se estivesse ciente delas, seria óbvio que o Logisim nem perto
chegaria a esse nível. Como um exemplo extremo, tenho um amigo que trabalha para
um grande fabricante de <i>chips</i>, e seu trabalho é de se preocupar com "bolhas" em
fios de <i>chips</i> com largura crescente em nanômetros e que possam levar a desconexão
aleatória.
</p> </li>
<p> <li> Mesmo fora isso, não sou um especialista em projeto de circuito, assim,
poderão existir erros na técnica de propagação da qual não tenha conhecimento.
Congratularei-me com as correções de especialistas.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Limitações</title>
</head>
<body bgcolor="FFFFFF">
<h1>Limitações</h1>
<p> O algoritmo de propagação do Logisim é sofisticado o suficiente
para quase todos os fins educativos, mas não é sofisticado o bastante
para o projeto de um circuito industrial. Em ordem das mais para as menos
contundentes, as deficiências da técnica de propagação do Logisim
incluem:
<ul>
<li> Exceto para os problemas de atrasos em portas, o Logisim não trata de forma
particular questões de temporização. É muito idealizada, de modo que um par de portas NOR
configuradas em um <i>latch</i> SR irá mudar em sincronia infinitamente, melhor
que, eventualmente, o circuito chegue a um estado permanente.
</p> </li>
<li> O Logisim não pode simular subcircuitos cujos pinos, às vezes, se comportem
como entradas e às vezes como saídas. Componentes criados usando Java poderão ter
tais pinos, como é o caso nas bibliotecas predefinidas, do circuito de memória da
biblioteca RAM que contém um pino D, que pode atuar tanto como entrada e como saída.
</p> </li>
<li> O Logisim suspenderá sua simulação após um número fixo de iterações
supondo haver um erro de oscilação.
É concebível, que em um grande circuito isso não se trate de problema que possa levar
à oscilação.
</p> </li>
<li> O Logisim não faz nada com relação à discriminação entre níveis de tensão:
Um bit poderá estar apenas ligado, desligado, não especificado, e em erro.
</p> </li>
<li> Há outras lacunas, também, que eu tenha omitido porque elas podem ser tão
obscuras que se estivesse ciente delas, seria óbvio que o Logisim nem perto
chegaria a esse nível. Como um exemplo extremo, tenho um amigo que trabalha para
um grande fabricante de <i>chips</i>, e seu trabalho é de se preocupar com "bolhas" em
fios de <i>chips</i> com largura crescente em nanômetros e que possam levar a desconexão
aleatória.
</p> </li>
<p> <li> Mesmo fora isso, não sou um especialista em projeto de circuito, assim,
poderão existir erros na técnica de propagação da qual não tenha conhecimento.
Congratularei-me com as correções de especialistas.
</p> </li>
</ul>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>

290
doc/pt/html/guide/subcirc/appear.html
View File

@ -1,145 +1,145 @@
<html>
<head>
<title>Editar aparência de subcircuitos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Editar aparência de subcircuitos</h1>
<h2>Aparência padrão</h2>
<p> Por padrão, quando um subcircuito é colocado dentro de um circuito maior,
ele será desenhado como um retângulo com um entalhe indicando a face norte do
subcircuito. Pinos serão colocados nas bordas do retângulo com base em sua direção:
pinos virados para o leste no <i>layout</i> (e que geralmente aparecem no lado oeste)
serão colocados no lado do retângulo oeste, de acordo com sua ordem de
cima para baixo no <i>layout</i>.
Pinos que estiverem virados para o sul no <i>layout</i> (normalmente na direção
norte) serão colocados no lado norte do retângulo, de acordo com a ordem da
esquerda para a direita no <i>layout</i>.
</p>
<p> O retângulo padrão poderá opcionalmente incluir algumas letras que aparecerão
no meio. Para especificar isso, escolher a ferramenta de seleção
(<img src="../../icons/select.gif" width="16" height="16">) e clicar no fundo
do <i>layout</i> do circuito. Isso irá mostrar a tabela de atributos do circuito,
incluindo o rótulo, direçao da etiqueta, e fonte de rótulos. O valor do atributo
Rótulo será desenhado no centro do retângulo; o atributo da direção da etiqueta
para personalizar o sentido em que o texto será desenhado, e, claro, atributo que
personaliza a fonte utilizada.
</p>
<h2>Aparência personalizada</h2>
<p> A aparência padrão é muito útil, e de fato Logisim existiu por muitos
anos, sem outra opção. Se, no entanto, preferir que o subcircuito seja
desenhado de forma diferente, você poderá selecionar
<q> Editar Aparência do Circuito </q> a partir do menu de projeto,
e o Logisim mudará da sua interface normal de
edição de <i>layout</i> para outra capaz de alterar a aparência do circuito.
Abaixo, editaremos a aparência do multiplexador 2:1, para que seja desenhada
como de costume por um trapézio, em vez de um retângulo.
(Você poderá ver a barra de ferramentas do projeto, logo abaixo da normal.
Isso poderá ser ativado através do menu de projeto, e ela permitirá uma mudança
mais rápida entre a edição de <i>layout</i> e da aparência.)
</p>
<blockquote> <img src="custom-appear.png" width="386" height="307"> </blockquote>
<p> Com a aparência do multiplexador 2:1 desenhada como acima,
o layout para o multiplexador 4:1, então, aparecerá como o que se segue.
</p>
<blockquote> <img src="custom-layout.png" width="386" height="307"> </blockquote>
<p> O editor de aparência é como um programa para desenho tradicional, mas há
alguns símbolos especiais para indicar como o desenho funcionará quando colocado
em um <i>layout</i> de circuito. Esses símbolos especiais não poderão ser removidos.
</p>
<ul>
<li> O círculo verde com uma linha que vem de fora, chamaremos de <q> âncora. </q>
Há exatamente uma âncora em cada subcircuito.
Cada componente em um circuito tem um único ponto para identificar a sua localização;
um usuário verá isso ao criar um novo componente.
O clique do mouse identificará apenas um local e, o componente será colocado
em relação a ele (geralmente com a saída principal na posição do mouse).
A âncora identificará a localização relativa ao desenho global do mouse
quando o subcircuito for criado. </p>
<p> A âncora também identificará a direção em sua aparência, conforme indicado pela
direção da linha de pontos da âncora de seu círculo. Ao colocar um subcircuito
em um <i>layout</i>, o usuário poderá mudar a face do subcircuito, a âncora indicará
a direção em que a aparência será orientada. No nosso exemplo, a âncora será
voltada para o leste, e cada instância do subcircuito no multiplexador 4:1
também estará voltada para o leste, então eles serão todos desenhados com a
mesma orientação que a aparência do multiplexador 2:1.
</p> </li>
<li> Os círculos azuis e quadrados com pontos são as <q> portas </q> dos subcircuitos
Haverá exatamente tantas portas quantos os pinos de entrada e saída no circuito.
Portas correspondentes às entradas serão desenhadas como quadrados, enquanto
as portas correspondentes às saídas serão desenhados como círculos.
Cada porta indicará como uma conexão para o circuito corresponderá a um
pino de entrada ou saída dentro do <i>layout</i>.
</p>
<p> Quando você selecionar uma porta, o Logisim indicará o pino correspondente
fazendo sobressair um diagrama em miniatura do layout no canto inferior direito
da janela, com o(s) pino(s) correspondente(s) desenhado(s_ em azul.
Isso não acontecerá quando todas as portas estiverem selecionados.
</p> </li>
</Ul>
<p> A barra de ferramentas contém aquelas para adicionar formas adicionais, conforme
listado abaixo com descrições de como as teclas shift e alt modificam o comportamento
da ferramenta. Além disso, clicando ou arrastando o mouse com a tecla control
pressionada normalmente remeterá a posição do mouse para o ponto mais próximo na grade.
</p>
<table> <tbody>
<td valign="top"> <img src="../../icons/select.gif" width="16" height="16"> </td>
<td> Selecionar, mover, copiar, colar e formas. </td> </tr>
<td valign="top"> <img src="../../icons/text.gif" width="16" height="16"> </td>
<td> Adicionar ou editar texto. </td> </tr>
<td valign="top"> <img src="../../icons/drawline.gif" width="16" height="16"> </td>
<td> Criar um segmento de linha. Shift-drag mantém o ângulo da linha em um múltiplo
de 45°. </td> </tr>
<td valign="top"> <img src="../../icons/drawcurv.gif" width="16" height="16"> </td>
<td> Criar uma curva Bézier quadrática.
Para o primeira arraste, onde você especificará os parâmetros da curva,
o shift-drag manterá os pontos da extremidade em um ângulo que será um múltiplo de 45°.
Em seguida, clicar para indicar a localização do ponto de controle;
shift-click garantirá que a curva será simétrica,
enquanto alt-click desenhará a curva que passará pelo ponto de controle. </td> </tr>
<td valign="top"> <img src="../../icons/drawplin.gif" width="16" height="16"> </td>
<td> Criar uma seqüência de linhas conectadas, cujos vértices serão indicados por
uma sucessão de clicks. Shift-click garantirá que o ângulo entre o
vértice anterior e o atual será um múltiplo de 45°.
Bastará um duplo clique ou pressionar a tecla Enter para concluir o desenho. </td> </tr>
<td valign="top"> <img src="../../icons/drawrect.gif" width="16" height="16"> </td>
<td> Criar um retângulo arrastando-o de um canto para outro oposto.
Shift-drag para criar um quadrado, e alt-drag para criar o retângulo a partir
do centro. </td> </tr>
<td valign="top"> <img src="../../icons/drawrrct.gif" width="16" height="16"> </td>
<td> Criar um retângulo com cantos arredondados arrastando-o de um canto para outro oposto.
Shift-drage para criar um quadrado, e alt-drag para criar o retângulo de a partir
do centro. </td> </tr>
<td valign="top"> <img src="../../icons/drawoval.gif" width="16" height="16"> </td>
<td> Criar uma oval mediante o arrastar de um canto de seu contorno para outro oposto.
Shift-drag para criar um círculo e alt-drag para criar a oval a partir
do centro. </td> </tr>
<td valign="top"> <img src="../../icons/drawpoly.gif" width="16" height="16"> </td>
<td> Criar um polígono arbitrário, cujos vértices serão indicados por
uma sucessão de cliques. Shift-click garantirá que o vértice estará a 45°
do anterior. Se der um duplo clique, pressionar a tecla Enter, ou clicar no
vértice inicial completará o desenho. </td> </tr>
</tbody> </table>
<p><strong>Próximo:</strong> <a href="debug.html">Depuração de subcircuitos</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Editar aparência de subcircuitos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Editar aparência de subcircuitos</h1>
<h2>Aparência padrão</h2>
<p> Por padrão, quando um subcircuito é colocado dentro de um circuito maior,
ele será desenhado como um retângulo com um entalhe indicando a face norte do
subcircuito. Pinos serão colocados nas bordas do retângulo com base em sua direção:
pinos virados para o leste no <i>layout</i> (e que geralmente aparecem no lado oeste)
serão colocados no lado do retângulo oeste, de acordo com sua ordem de
cima para baixo no <i>layout</i>.
Pinos que estiverem virados para o sul no <i>layout</i> (normalmente na direção
norte) serão colocados no lado norte do retângulo, de acordo com a ordem da
esquerda para a direita no <i>layout</i>.
</p>
<p> O retângulo padrão poderá opcionalmente incluir algumas letras que aparecerão
no meio. Para especificar isso, escolher a ferramenta de seleção
(<img src="../../icons/select.gif" width="16" height="16">) e clicar no fundo
do <i>layout</i> do circuito. Isso irá mostrar a tabela de atributos do circuito,
incluindo o rótulo, direçao da etiqueta, e fonte de rótulos. O valor do atributo
Rótulo será desenhado no centro do retângulo; o atributo da direção da etiqueta
para personalizar o sentido em que o texto será desenhado, e, claro, atributo que
personaliza a fonte utilizada.
</p>
<h2>Aparência personalizada</h2>
<p> A aparência padrão é muito útil, e de fato Logisim existiu por muitos
anos, sem outra opção. Se, no entanto, preferir que o subcircuito seja
desenhado de forma diferente, você poderá selecionar
<q> Editar Aparência do Circuito </q> a partir do menu de projeto,
e o Logisim mudará da sua interface normal de
edição de <i>layout</i> para outra capaz de alterar a aparência do circuito.
Abaixo, editaremos a aparência do multiplexador 2:1, para que seja desenhada
como de costume por um trapézio, em vez de um retângulo.
(Você poderá ver a barra de ferramentas do projeto, logo abaixo da normal.
Isso poderá ser ativado através do menu de projeto, e ela permitirá uma mudança
mais rápida entre a edição de <i>layout</i> e da aparência.)
</p>
<blockquote> <img src="custom-appear.png" width="386" height="307"> </blockquote>
<p> Com a aparência do multiplexador 2:1 desenhada como acima,
o layout para o multiplexador 4:1, então, aparecerá como o que se segue.
</p>
<blockquote> <img src="custom-layout.png" width="386" height="307"> </blockquote>
<p> O editor de aparência é como um programa para desenho tradicional, mas há
alguns símbolos especiais para indicar como o desenho funcionará quando colocado
em um <i>layout</i> de circuito. Esses símbolos especiais não poderão ser removidos.
</p>
<ul>
<li> O círculo verde com uma linha que vem de fora, chamaremos de <q> âncora. </q>
Há exatamente uma âncora em cada subcircuito.
Cada componente em um circuito tem um único ponto para identificar a sua localização;
um usuário verá isso ao criar um novo componente.
O clique do mouse identificará apenas um local e, o componente será colocado
em relação a ele (geralmente com a saída principal na posição do mouse).
A âncora identificará a localização relativa ao desenho global do mouse
quando o subcircuito for criado. </p>
<p> A âncora também identificará a direção em sua aparência, conforme indicado pela
direção da linha de pontos da âncora de seu círculo. Ao colocar um subcircuito
em um <i>layout</i>, o usuário poderá mudar a face do subcircuito, a âncora indicará
a direção em que a aparência será orientada. No nosso exemplo, a âncora será
voltada para o leste, e cada instância do subcircuito no multiplexador 4:1
também estará voltada para o leste, então eles serão todos desenhados com a
mesma orientação que a aparência do multiplexador 2:1.
</p> </li>
<li> Os círculos azuis e quadrados com pontos são as <q> portas </q> dos subcircuitos
Haverá exatamente tantas portas quantos os pinos de entrada e saída no circuito.
Portas correspondentes às entradas serão desenhadas como quadrados, enquanto
as portas correspondentes às saídas serão desenhados como círculos.
Cada porta indicará como uma conexão para o circuito corresponderá a um
pino de entrada ou saída dentro do <i>layout</i>.
</p>
<p> Quando você selecionar uma porta, o Logisim indicará o pino correspondente
fazendo sobressair um diagrama em miniatura do layout no canto inferior direito
da janela, com o(s) pino(s) correspondente(s) desenhado(s_ em azul.
Isso não acontecerá quando todas as portas estiverem selecionados.
</p> </li>
</Ul>
<p> A barra de ferramentas contém aquelas para adicionar formas adicionais, conforme
listado abaixo com descrições de como as teclas shift e alt modificam o comportamento
da ferramenta. Além disso, clicando ou arrastando o mouse com a tecla control
pressionada normalmente remeterá a posição do mouse para o ponto mais próximo na grade.
</p>
<table> <tbody>
<td valign="top"> <img src="../../icons/select.gif" width="16" height="16"> </td>
<td> Selecionar, mover, copiar, colar e formas. </td> </tr>
<td valign="top"> <img src="../../icons/text.gif" width="16" height="16"> </td>
<td> Adicionar ou editar texto. </td> </tr>
<td valign="top"> <img src="../../icons/drawline.gif" width="16" height="16"> </td>
<td> Criar um segmento de linha. Shift-drag mantém o ângulo da linha em um múltiplo
de 45°. </td> </tr>
<td valign="top"> <img src="../../icons/drawcurv.gif" width="16" height="16"> </td>
<td> Criar uma curva Bézier quadrática.
Para o primeira arraste, onde você especificará os parâmetros da curva,
o shift-drag manterá os pontos da extremidade em um ângulo que será um múltiplo de 45°.
Em seguida, clicar para indicar a localização do ponto de controle;
shift-click garantirá que a curva será simétrica,
enquanto alt-click desenhará a curva que passará pelo ponto de controle. </td> </tr>
<td valign="top"> <img src="../../icons/drawplin.gif" width="16" height="16"> </td>
<td> Criar uma seqüência de linhas conectadas, cujos vértices serão indicados por
uma sucessão de clicks. Shift-click garantirá que o ângulo entre o
vértice anterior e o atual será um múltiplo de 45°.
Bastará um duplo clique ou pressionar a tecla Enter para concluir o desenho. </td> </tr>
<td valign="top"> <img src="../../icons/drawrect.gif" width="16" height="16"> </td>
<td> Criar um retângulo arrastando-o de um canto para outro oposto.
Shift-drag para criar um quadrado, e alt-drag para criar o retângulo a partir
do centro. </td> </tr>
<td valign="top"> <img src="../../icons/drawrrct.gif" width="16" height="16"> </td>
<td> Criar um retângulo com cantos arredondados arrastando-o de um canto para outro oposto.
Shift-drage para criar um quadrado, e alt-drag para criar o retângulo de a partir
do centro. </td> </tr>
<td valign="top"> <img src="../../icons/drawoval.gif" width="16" height="16"> </td>
<td> Criar uma oval mediante o arrastar de um canto de seu contorno para outro oposto.
Shift-drag para criar um círculo e alt-drag para criar a oval a partir
do centro. </td> </tr>
<td valign="top"> <img src="../../icons/drawpoly.gif" width="16" height="16"> </td>
<td> Criar um polígono arbitrário, cujos vértices serão indicados por
uma sucessão de cliques. Shift-click garantirá que o vértice estará a 45°
do anterior. Se der um duplo clique, pressionar a tecla Enter, ou clicar no
vértice inicial completará o desenho. </td> </tr>
</tbody> </table>
<p><strong>Próximo:</strong> <a href="debug.html">Depuração de subcircuitos</a>.</p>
</body>
</html>

76
doc/pt/html/guide/subcirc/creating.html
View File

@ -1,38 +1,38 @@
<html>
<head>
<title>Criar circuitos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Criar circuitos</h1>
<p> Cada projeto Logisim é realmente uma biblioteca de circuitos. Em
sua forma mais simples, cada projeto terá um único circuito (chamado
"Principal" por padrão), mas é fácil adicionar mais:
basta selecionar Adicionar Circuito ... a partir do menu Projeto, e
digitar qualquer nome. Você poderá aproveitar, então, o novo circuito que criar.
</p>
<p> Suponha que queiramos construir um multiplexador 2:1 com o nome "MUX 2:1".
Após adicionar o circuito, Logisim será parecido com isso.
</p>
<center> <img src="2-add.png" width="381" height="254"> </center>
<p> No painel de explorador, você poderá ver que o projeto agora
conterá dois circuitos, "principal" e "MUX 2:1". O Logisim desenhará
uma lupa sobre o ícone do circuito a ser visualizado, o nome corrente
do circuito também aparecerá na barra de título da janela.
</p>
<p> Após a edição do circuito para parecer como um multiplexador 2:1,
poderíamos ter o circuito a seguir.
</p>
<center><img src="2-done.png" width="381" height="254"></center>
<p><strong>Próximo:</strong> <a href="using.html">Usar subcircuitos</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Criar circuitos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Criar circuitos</h1>
<p> Cada projeto Logisim é realmente uma biblioteca de circuitos. Em
sua forma mais simples, cada projeto terá um único circuito (chamado
"Principal" por padrão), mas é fácil adicionar mais:
basta selecionar Adicionar Circuito ... a partir do menu Projeto, e
digitar qualquer nome. Você poderá aproveitar, então, o novo circuito que criar.
</p>
<p> Suponha que queiramos construir um multiplexador 2:1 com o nome "MUX 2:1".
Após adicionar o circuito, Logisim será parecido com isso.
</p>
<center> <img src="2-add.png" width="381" height="254"> </center>
<p> No painel de explorador, você poderá ver que o projeto agora
conterá dois circuitos, "principal" e "MUX 2:1". O Logisim desenhará
uma lupa sobre o ícone do circuito a ser visualizado, o nome corrente
do circuito também aparecerá na barra de título da janela.
</p>
<p> Após a edição do circuito para parecer como um multiplexador 2:1,
poderíamos ter o circuito a seguir.
</p>
<center><img src="2-done.png" width="381" height="254"></center>
<p><strong>Próximo:</strong> <a href="using.html">Usar subcircuitos</a>.</p>
</body>
</html>

102
doc/pt/html/guide/subcirc/debug.html
View File

@ -1,51 +1,51 @@
<html>
<head>
<title>Depurar subcircuitos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Depurar subcircuitos</h1>
<p> Ao testar circuitos maiores, você provavelmente encontrará <i>bugs</i>.
Para se descobrir o que estiver acontecendo de errado, explorar o que estiver
acontecendo no subcircuitos enquanto estiver testando o circuito global poderá
ser bastante útil.
Você poderá ver o estado do subcircuito de duas maneiras: primeiro, você poderá
abrir o menu <i>pop-up</i> do subcircuito pelo botão direito do mouse ou
<i>control-click</i>, e escolher a opção Exibir.
</p>
<center> <img src="4-delve.png" width="381" height="254"> </center>
<p> Ou se você tiver a ferramenta Testar (Poke) selecionada, você poderá clicar
no circuito, e uma lupa aparecerá sobre o seu centro; um duplo clique na lupa que
aparecerá e também entrará no estado do subcircuito.
</p>
<center> <img src="2-delve.png" width="381" height="254"> </center>
<p> Observar que os valores dos pinos no subcircuito corresponderão aos valores
que estiverem sendo enviados a esses no circuito que os contém.
</p>
<p> Enquanto no subcircuito, você terá permissão para alterar o circuito. Se as
mudanças afetarem qualquer das saídas do subcircuito, elas serão propagadas para esse.
Uma exceção: as entradas do subcircuito serão determinadas com base
nos valores que entram no supercircuito, por isso não faz sentido alternar esses valores.
Se você tentar introduzir uma modificação no subcircuito, uma caixa de diálogo se
abrirá perguntando se <q> o pino está ligado ao estado do supercircuito.
Criar um estado novo para o circuito? </q> Se clicar em Não, cancelarará o pedido de
alteração, se clicar em Sim irá criar uma cópia dos estados vistos,
diferente do circuito externo, com o pino de entrada alterado.
</p>
<p> Depois de ter completado a visualização e/ou edição, poderá retornar ao circuito
original ao clicar duas vezes no circuito principal no painel do Explorador, ou
através do submenu Ir Ao Estado do menu Simulação.
</p>
<p><strong>Próximo:</strong> <a href="library.html">Bibliotecas do Logisim</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Depurar subcircuitos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Depurar subcircuitos</h1>
<p> Ao testar circuitos maiores, você provavelmente encontrará <i>bugs</i>.
Para se descobrir o que estiver acontecendo de errado, explorar o que estiver
acontecendo no subcircuitos enquanto estiver testando o circuito global poderá
ser bastante útil.
Você poderá ver o estado do subcircuito de duas maneiras: primeiro, você poderá
abrir o menu <i>pop-up</i> do subcircuito pelo botão direito do mouse ou
<i>control-click</i>, e escolher a opção Exibir.
</p>
<center> <img src="4-delve.png" width="381" height="254"> </center>
<p> Ou se você tiver a ferramenta Testar (Poke) selecionada, você poderá clicar
no circuito, e uma lupa aparecerá sobre o seu centro; um duplo clique na lupa que
aparecerá e também entrará no estado do subcircuito.
</p>
<center> <img src="2-delve.png" width="381" height="254"> </center>
<p> Observar que os valores dos pinos no subcircuito corresponderão aos valores
que estiverem sendo enviados a esses no circuito que os contém.
</p>
<p> Enquanto no subcircuito, você terá permissão para alterar o circuito. Se as
mudanças afetarem qualquer das saídas do subcircuito, elas serão propagadas para esse.
Uma exceção: as entradas do subcircuito serão determinadas com base
nos valores que entram no supercircuito, por isso não faz sentido alternar esses valores.
Se você tentar introduzir uma modificação no subcircuito, uma caixa de diálogo se
abrirá perguntando se <q> o pino está ligado ao estado do supercircuito.
Criar um estado novo para o circuito? </q> Se clicar em Não, cancelarará o pedido de
alteração, se clicar em Sim irá criar uma cópia dos estados vistos,
diferente do circuito externo, com o pino de entrada alterado.
</p>
<p> Depois de ter completado a visualização e/ou edição, poderá retornar ao circuito
original ao clicar duas vezes no circuito principal no painel do Explorador, ou
através do submenu Ir Ao Estado do menu Simulação.
</p>
<p><strong>Próximo:</strong> <a href="library.html">Bibliotecas do Logisim</a>.</p>
</body>
</html>

74
doc/pt/html/guide/subcirc/index.html
View File

@ -1,37 +1,37 @@
<html>
<head>
<title>Subcircuitos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Subcircuitos</h1>
<p> Como você poderá construir circuitos cada vez mais sofisticados,
poderá querer também construir circuitos menores que possam ser usados
várias vezes como um módulo embutido em circuitos maiores.
No Logisim, um circuito menor, que seja usado em outro maior,
será chamado de <strong> subcircuito </strong>.
</p>
<p> Se você estiver familiarizado com programação de computadores,
também deverá estar com conceito de subprograma, quer se trate de uma
<em> sub-rotina</em>, <em> função</em>, <em> método</em>, ou <em> procedimento </em>
na sua linguagem de preferência.
O conceito de subcircuito é análogo a isso, e serve ao mesmo propósito:
para dividir um trabalho em porções menores,
para poupar esforço de definir o mesmo conceito várias vezes, e
para facilitar a depuração.
</p>
<blockquote> <a href="creating.html"> Criar circuitos </a>
<br> <a href="using.html"> Usar subcircuitos </a>
<br> <a href="appear.html"> Editar aparência de subcircuito </a>
<br> <a href="debug.html"> Depurar subcircuitos </a>
<br> <a href="library.html"> Bibliotecas do Logisim </a>
</blockquote>
<p><strong>Próximo:</strong> <a href="creating.html">Criar circuitos</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Subcircuitos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Subcircuitos</h1>
<p> Como você poderá construir circuitos cada vez mais sofisticados,
poderá querer também construir circuitos menores que possam ser usados
várias vezes como um módulo embutido em circuitos maiores.
No Logisim, um circuito menor, que seja usado em outro maior,
será chamado de <strong> subcircuito </strong>.
</p>
<p> Se você estiver familiarizado com programação de computadores,
também deverá estar com conceito de subprograma, quer se trate de uma
<em> sub-rotina</em>, <em> função</em>, <em> método</em>, ou <em> procedimento </em>
na sua linguagem de preferência.
O conceito de subcircuito é análogo a isso, e serve ao mesmo propósito:
para dividir um trabalho em porções menores,
para poupar esforço de definir o mesmo conceito várias vezes, e
para facilitar a depuração.
</p>
<blockquote> <a href="creating.html"> Criar circuitos </a>
<br> <a href="using.html"> Usar subcircuitos </a>
<br> <a href="appear.html"> Editar aparência de subcircuito </a>
<br> <a href="debug.html"> Depurar subcircuitos </a>
<br> <a href="library.html"> Bibliotecas do Logisim </a>
</blockquote>
<p><strong>Próximo:</strong> <a href="creating.html">Criar circuitos</a>.</p>
</body>
</html>

84
doc/pt/html/guide/subcirc/library.html
View File

@ -1,42 +1,42 @@
<html>
<head>
<title>Bibliotecas do Logisim</title>
</head>
<body bgcolor="FFFFFF">
<h1>Bibliotecas do Logisim</h1>
<p> Cada projeto Logisim é também uma biblioteca que poderá ser carregada
em outros projetos: basta salvar em um arquivo e depois carregá-la
como biblioteca em outro projeto. Todos os circuitos definidos no
primeiro projeto estarão disponíveis como subcircuitos para o segundo.
Esse recurso permite reutilizar componentes comuns em projetos
e compartilhar componentes favoritos com seus colegas (ou alunos).
</p>
<p> Cada projeto possui um "circuito principal", que poderá ser alterado
para se referir ao circuito corrente de acordo com a opção Marcar Como Principal
no menu Projeto. O <em> apenas </em> significa que o circuito principal é
o único a ser exibido quando você abrir pela primeira vez o projeto.
O nome padrão do circuito em um arquivo recém-criado
("Principal") não tem nenhum significado algum, e você pode sentir-se livre para
apagar ou mudar o nome desse circuito.
</p>
<p> Com uma biblioteca Logisim carregada, você terá permissão para ver os circuitos e
manipular seus estados, mas o Logisim irá impedi-lo de alterar os aspectos dos circuitos
e outros dados armazenados no arquivo.
</p>
<p> Se você quiser alterar um circuito em uma biblioteca já carregada,
então, será preciso abri-la separadamente, no Logisim. Assim que você a salvar,
outro projeto deverá carregar a versão modificada imediatamente, mas se isso
não acontecer, você poderá com usar o botão direito do mouse sobre a pasta
da biblioteca no painel do Explorador e escolher Atualizar Biblioteca.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Bibliotecas do Logisim</title>
</head>
<body bgcolor="FFFFFF">
<h1>Bibliotecas do Logisim</h1>
<p> Cada projeto Logisim é também uma biblioteca que poderá ser carregada
em outros projetos: basta salvar em um arquivo e depois carregá-la
como biblioteca em outro projeto. Todos os circuitos definidos no
primeiro projeto estarão disponíveis como subcircuitos para o segundo.
Esse recurso permite reutilizar componentes comuns em projetos
e compartilhar componentes favoritos com seus colegas (ou alunos).
</p>
<p> Cada projeto possui um "circuito principal", que poderá ser alterado
para se referir ao circuito corrente de acordo com a opção Marcar Como Principal
no menu Projeto. O <em> apenas </em> significa que o circuito principal é
o único a ser exibido quando você abrir pela primeira vez o projeto.
O nome padrão do circuito em um arquivo recém-criado
("Principal") não tem nenhum significado algum, e você pode sentir-se livre para
apagar ou mudar o nome desse circuito.
</p>
<p> Com uma biblioteca Logisim carregada, você terá permissão para ver os circuitos e
manipular seus estados, mas o Logisim irá impedi-lo de alterar os aspectos dos circuitos
e outros dados armazenados no arquivo.
</p>
<p> Se você quiser alterar um circuito em uma biblioteca já carregada,
então, será preciso abri-la separadamente, no Logisim. Assim que você a salvar,
outro projeto deverá carregar a versão modificada imediatamente, mas se isso
não acontecer, você poderá com usar o botão direito do mouse sobre a pasta
da biblioteca no painel do Explorador e escolher Atualizar Biblioteca.
</p>
<p><strong>Próximo:</strong> <em><a href="../index.html">Guia do usuário</a></em>.</p>
</body>
</html>

170
doc/pt/html/guide/subcirc/using.html
View File

@ -1,85 +1,85 @@
<html>
<head>
<title>Usar subcircuitos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Usar subcircuitos</h1>
<p> Agora, suponha que queiramos construir um multiplexador 4:1, utilizando
instâncias de nosso multiplexador 2:1. É claro que gostaríamos de criar, primeiro,
um novo circuito, que chamaremos de "MUX 4:1". Para adicionar multiplexadores 2:1
em nosso circuito, clicar no circuito <em> MUX 2:1 </em> uma vez no painel do
Explorador para selecioná-lo como uma ferramenta, e depois poderemos juntar cópias
disso, representadas como caixas, clicando na área de desenho.
</p>
<center> <img src="4-add.png" width="381" height="254"> </center>
<p> Se você clicar duas vezes no circuito MUX 2:1 no painel do explorador,
então a janela mudará para a edição do circuito MUX 2:01.
</p>
<p> Depois de construir o circuito, obteremos o seguinte. </p>
<center> <img src="4-done.png" width="381" height="254"> </center>
<p> Nosso circuito multiplexador 4:1 usará três cópias do
multiplexador 2:1, cada uma desenhada como uma caixa com conexões em suas bordas.
Os pinos nessa caixa corresponderão aos pinos de entrada e saída no
circuito MUX 2:1. Os dois pinos no lado oeste da caixa corresponderão
aos dois pinos direcionados para leste no circuito MUX 2:1; o pino do
lado leste da caixa corresponderá ao pino a oeste no MUX 2:1
(que passa a ser um pino de saída) e os pinos no sul da caixa
corresponderão aos pinos ao norte do MUX 2:1. A ordem dos dois pinos no
lado oeste da caixa corresponderão aos mesmos de cima para baixo,
de acordo com a concepção do subcircuito. (Se houvesse vários pinos
no norte da caixa ou do lado sul, eles corresponderiam à mesma
ordem da esquerda para a direita no subcircuito.)
</p>
<p> Se os pinos no <i>layout</i> do subcircuito tiverem rótulos associados
eles, então Logisim irá mostrar a etiqueta como uma <strong> dica </strong>
(isto é, uma caixa de texto temporária) quando o usuário passar o mouse sobre o
localização correspondente do componente no subcircuito. (Se você encontrar essas
dicas irritantes, poderá desativá-las através da janela
<a href="../opts/canvas.html"> Opções de Projeto </a> na guia Área de Desenho.)
</p>
<center> <img src="4-tip.png" width="381" height="254"> </center>
<p> Vários outros componentes irão mostrar essas dicas também: para alguns dos
pinos de um <a href="../../libs/mem/flipflops.html"> <i>flip-flop</i> </a> predefinido,
por exemplo, ao passar sobre ele explicará a função do que faz o pino.
</p>
<p> Aliás, todos os pinos de um circuito deverão ser uma entrada ou
uma saída. Muitos <i>chips</i> fabricados têm pinos que se comportam como uma entrada
em algumas situações e como uma saída em outras, você não poderá construir
esses tipos de <i>chips</i> dentro Logisim (pelo menos na versão atual).
</p>
<p> O Logisim irá manter informações de estado diferentes para todos os subcircuitos
que aparecerem. Por exemplo, se um circuito contiver um <i>flip-flop</i>,
e se for usado diversas vezes como subcircuito, então cada um deles
terá o seu próprio valor quando for simular o circuito maior.
</p>
<p> Um vez que tenhamos o multiplexador 4:1 definido, poderemos usá-lo
em outros circuitos. O Logisim não tem limites em quão profundo os circuitos
possam ser aninhados - embora ele irá opor-se à colocação desses dentro de si próprios!
</p>
<strong> Nota: </strong> Não há nada de errado com a edição de um
circuito que estiver sendo usado como um subcircuito, na verdade, isso é muito
comum. Esteja ciente, no entanto, que quaisquer alterações nos pinos de um circuito
(adicionando, excluindo ou movendo-os) irá reorganizá-los também naquele que o contiver.
Assim, se você alterar os pinos em um circuito, você também terá necessidade
de editar qualquer circuito que usá-lo como um subcircuito.
</p>
<p><strong>Próximo:</strong> <a href="appear.html">Editar a aparência de subcircuito</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Usar subcircuitos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Usar subcircuitos</h1>
<p> Agora, suponha que queiramos construir um multiplexador 4:1, utilizando
instâncias de nosso multiplexador 2:1. É claro que gostaríamos de criar, primeiro,
um novo circuito, que chamaremos de "MUX 4:1". Para adicionar multiplexadores 2:1
em nosso circuito, clicar no circuito <em> MUX 2:1 </em> uma vez no painel do
Explorador para selecioná-lo como uma ferramenta, e depois poderemos juntar cópias
disso, representadas como caixas, clicando na área de desenho.
</p>
<center> <img src="4-add.png" width="381" height="254"> </center>
<p> Se você clicar duas vezes no circuito MUX 2:1 no painel do explorador,
então a janela mudará para a edição do circuito MUX 2:01.
</p>
<p> Depois de construir o circuito, obteremos o seguinte. </p>
<center> <img src="4-done.png" width="381" height="254"> </center>
<p> Nosso circuito multiplexador 4:1 usará três cópias do
multiplexador 2:1, cada uma desenhada como uma caixa com conexões em suas bordas.
Os pinos nessa caixa corresponderão aos pinos de entrada e saída no
circuito MUX 2:1. Os dois pinos no lado oeste da caixa corresponderão
aos dois pinos direcionados para leste no circuito MUX 2:1; o pino do
lado leste da caixa corresponderá ao pino a oeste no MUX 2:1
(que passa a ser um pino de saída) e os pinos no sul da caixa
corresponderão aos pinos ao norte do MUX 2:1. A ordem dos dois pinos no
lado oeste da caixa corresponderão aos mesmos de cima para baixo,
de acordo com a concepção do subcircuito. (Se houvesse vários pinos
no norte da caixa ou do lado sul, eles corresponderiam à mesma
ordem da esquerda para a direita no subcircuito.)
</p>
<p> Se os pinos no <i>layout</i> do subcircuito tiverem rótulos associados
eles, então Logisim irá mostrar a etiqueta como uma <strong> dica </strong>
(isto é, uma caixa de texto temporária) quando o usuário passar o mouse sobre o
localização correspondente do componente no subcircuito. (Se você encontrar essas
dicas irritantes, poderá desativá-las através da janela
<a href="../opts/canvas.html"> Opções de Projeto </a> na guia Área de Desenho.)
</p>
<center> <img src="4-tip.png" width="381" height="254"> </center>
<p> Vários outros componentes irão mostrar essas dicas também: para alguns dos
pinos de um <a href="../../libs/mem/flipflops.html"> <i>flip-flop</i> </a> predefinido,
por exemplo, ao passar sobre ele explicará a função do que faz o pino.
</p>
<p> Aliás, todos os pinos de um circuito deverão ser uma entrada ou
uma saída. Muitos <i>chips</i> fabricados têm pinos que se comportam como uma entrada
em algumas situações e como uma saída em outras, você não poderá construir
esses tipos de <i>chips</i> dentro Logisim (pelo menos na versão atual).
</p>
<p> O Logisim irá manter informações de estado diferentes para todos os subcircuitos
que aparecerem. Por exemplo, se um circuito contiver um <i>flip-flop</i>,
e se for usado diversas vezes como subcircuito, então cada um deles
terá o seu próprio valor quando for simular o circuito maior.
</p>
<p> Um vez que tenhamos o multiplexador 4:1 definido, poderemos usá-lo
em outros circuitos. O Logisim não tem limites em quão profundo os circuitos
possam ser aninhados - embora ele irá opor-se à colocação desses dentro de si próprios!
</p>
<strong> Nota: </strong> Não há nada de errado com a edição de um
circuito que estiver sendo usado como um subcircuito, na verdade, isso é muito
comum. Esteja ciente, no entanto, que quaisquer alterações nos pinos de um circuito
(adicionando, excluindo ou movendo-os) irá reorganizá-los também naquele que o contiver.
Assim, se você alterar os pinos em um circuito, você também terá necessidade
de editar qualquer circuito que usá-lo como um subcircuito.
</p>
<p><strong>Próximo:</strong> <a href="appear.html">Editar a aparência de subcircuito</a>.</p>
</body>
</html>

98
doc/pt/html/guide/tutorial/index.html
View File

@ -1,49 +1,49 @@
<html>
<head>
<title>Tutorial para o principiante</title>
</head>
<body bgcolor="FFFFFF">
<h1>Tutorial para o principiante</h1>
<p><b>Próximo:</b> <a href="tutor-orient.html">Passo 0: Oriente-se</a></p>
<p>Bem-vindo ao Logisim!</p>
<p> Logisim permite projetar e simular circuitos digitais. Foi planejado
como ferramenta educacional para ajudar você a aprender como os circuitos
funcionam.
</p>
<p> Para praticar o uso Logisim, vamos construir um circuito XOR -
ou seja, um circuito que tem duas entradas (que chamaremos <em> x </em> e
<em> y </em>) e fornecerá a saída igual a 0 se as entradas
forem iguais e 1 se forem diferentes.
A tabela a seguir ilustra a tabela-verdade.
<center> <img src="xor-table.png" width="163" height="131"> </center>
Poderíamos projetar tal circuito em papel.
<center> <img src="xor-circ.png" width="323" height="147"> </center>
Mas só porque ele está no papel não significa que ele está certo.
Para verificar o nosso trabalho, nós iremos desenhá-lo no Logisim e testá-lo.
Como um bônus adicional, nós obteremos um circuito que se parecerá melhor
do que aquele que você provavelmente faria à mão.
</p>
<p> <a href="tutor-orient.html"> Passo 0: Orientar-se </a>
<br> <a href="tutor-gates.html"> Passo 1: Acrescentar portas </a>
<br> <a href="tutor-wires.html"> Passo 2: Acrescentar conexões </a>
<br> <a href="tutor-text.html"> Passo 3: Acrescentar texto </a>
<a <br> href="tutor-test.html"> Passo 4: Testar seu circuito </a>
</p>
<p> Aproveite o seu contrutor de circuitos. </p>
<p><b>Próximo:</b> <a href="tutor-orient.html">Passo 0: Orientar-se</a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Tutorial para o principiante</title>
</head>
<body bgcolor="FFFFFF">
<h1>Tutorial para o principiante</h1>
<p><b>Próximo:</b> <a href="tutor-orient.html">Passo 0: Oriente-se</a></p>
<p>Bem-vindo ao Logisim!</p>
<p> Logisim permite projetar e simular circuitos digitais. Foi planejado
como ferramenta educacional para ajudar você a aprender como os circuitos
funcionam.
</p>
<p> Para praticar o uso Logisim, vamos construir um circuito XOR -
ou seja, um circuito que tem duas entradas (que chamaremos <em> x </em> e
<em> y </em>) e fornecerá a saída igual a 0 se as entradas
forem iguais e 1 se forem diferentes.
A tabela a seguir ilustra a tabela-verdade.
<center> <img src="xor-table.png" width="163" height="131"> </center>
Poderíamos projetar tal circuito em papel.
<center> <img src="xor-circ.png" width="323" height="147"> </center>
Mas só porque ele está no papel não significa que ele está certo.
Para verificar o nosso trabalho, nós iremos desenhá-lo no Logisim e testá-lo.
Como um bônus adicional, nós obteremos um circuito que se parecerá melhor
do que aquele que você provavelmente faria à mão.
</p>
<p> <a href="tutor-orient.html"> Passo 0: Orientar-se </a>
<br> <a href="tutor-gates.html"> Passo 1: Acrescentar portas </a>
<br> <a href="tutor-wires.html"> Passo 2: Acrescentar conexões </a>
<br> <a href="tutor-text.html"> Passo 3: Acrescentar texto </a>
<a <br> href="tutor-test.html"> Passo 4: Testar seu circuito </a>
</p>
<p> Aproveite o seu contrutor de circuitos. </p>
<p><b>Próximo:</b> <a href="tutor-orient.html">Passo 0: Orientar-se</a></p>
</body>
</html>

140
doc/pt/html/guide/tutorial/tutor-gates.html
View File

@ -1,70 +1,70 @@
<html>
<head>
<title>Tutorial: Acrescentar portas</title>
</head>
<body bgcolor="FFFFFF">
<p><b>Próximo:</b> <a href="tutor-wires.html">Passo 2: Acrescentar conexões</a></p>
<h2>Passo 1: Acrescentar portas</h2>
<p> Lembre-se que estamos tentando construir o circuito a seguir em Logisim. </p>
<center> <img src="xor-circ.png" width="323" height="147"> </center>
<p> Sugiro a construção de um circuito, inserindo as portas primeiro para formar
uma espécie de esqueleto e, em seguida, conectá-los com os fios. A primeira coisa
que vamos fazer é adicionar as duas portas AND. Clique na porta AND na barra
de ferramentas (<img src="../../icons/andGate.gif" width="16" height="16">,
a penúltima listada).
Em seguida, clique na área de edição onde você desejar que a primeira porta AND
deva ficar. Certifique-se de deixar espaço suficiente para outras coisas do lado
esquerdo. Em seguida, clique na porta AND novamente e coloque a segunda mais abaixo.
</p>
<center> <img src="shot-ands.png" width="473" height="247"> </center>
<p> Observe que haverá cinco pontos do lado esquerdo da porta AND. Esses serão
os pontos onde os fios poderão ser conectados. Acontece que nós iremos usar apenas
dois deles para o nosso circuito XOR, mas para outros circuitos, você poderá achar
mais útil ter mais de duas conexões em uma porta AND.
</p>
<p> Agora adicionaremos as outras portas. Primeiro clique sobre a porta OR
(<img src="../../icons/orGate.gif" width="16" height="16">);
em seguida, clique onde você quiser colocá-la. E coloque também duas portas NOT
buscando-as em (<img src="../../icons/notGate.gif" width="16" height="16">).
</p>
<center> <img src="shot-gates.png" width="473" height="247"> </center>
<p> Deixei um pouco de espaço entre as portas NOT e as portas AND, se você
quisero, porém, poderá colocá-las umas junto às outrss e poupar
o esforço de conectá-las por um fio mais tarde. </p>
<p> Agora queremos adicionar as duas entradas <var> x </var> e <var> y </var>
no diagrama. Selecione uma entrada
(<img src="../../icons/pinInput.gif" width="16" height="16">),
e coloque os pinos voltados para baixo.
Você também deverá colocar uma saída junto à porta OR, usando
(<img Src="../../icons/pinOutputReversed.gif" width="16" height="16">).
(Novamente, estou deixando um pouco de espaço entre a porta OR e a saída,
mas você poderá optar por colocá-las uma ao lado da outra.) </p>
<center> <img src="shot-comps.png" width="473" height="247"> </center>
<p> Se você achar que não gosta de onde colocou alguma coisa, poderá
selecioná-la usando a ferramenta Editar
(<img src="../../icons/select.gif" width="16" height="16">)
e arrastá-la para o local desejado. Ou ainda poderá excluí-la totalmente,
selecionando Excluir no menu Editar ou pressionar a tecla Delete.
</p>
<p> Quando você colocar cada componente do circuito, você verá que, logo que
ele for colocado, o Logisim reverte para a ferramenta Editar para que possa
mover o componente recém-colocado ou (como veremos em breve) conectar o componente
a outros, usando fios. Se quiser acrescentar uma cópia do recém-colocado
componente, um atalho é pressionar Control-D para duplicar a seleção.
(Alguns computadores usam outra teclas para menus, tais como a tecla de comando no
Macintosh. Você irá pressionar essa tecla junto com a tecla D).
</p>
<p><b>Próximo:</b> <a href="tutor-wires.html">Passo 2: Acrescentar conexões</a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Tutorial: Acrescentar portas</title>
</head>
<body bgcolor="FFFFFF">
<p><b>Próximo:</b> <a href="tutor-wires.html">Passo 2: Acrescentar conexões</a></p>
<h2>Passo 1: Acrescentar portas</h2>
<p> Lembre-se que estamos tentando construir o circuito a seguir em Logisim. </p>
<center> <img src="xor-circ.png" width="323" height="147"> </center>
<p> Sugiro a construção de um circuito, inserindo as portas primeiro para formar
uma espécie de esqueleto e, em seguida, conectá-los com os fios. A primeira coisa
que vamos fazer é adicionar as duas portas AND. Clique na porta AND na barra
de ferramentas (<img src="../../icons/andGate.gif" width="16" height="16">,
a penúltima listada).
Em seguida, clique na área de edição onde você desejar que a primeira porta AND
deva ficar. Certifique-se de deixar espaço suficiente para outras coisas do lado
esquerdo. Em seguida, clique na porta AND novamente e coloque a segunda mais abaixo.
</p>
<center> <img src="shot-ands.png" width="473" height="247"> </center>
<p> Observe que haverá cinco pontos do lado esquerdo da porta AND. Esses serão
os pontos onde os fios poderão ser conectados. Acontece que nós iremos usar apenas
dois deles para o nosso circuito XOR, mas para outros circuitos, você poderá achar
mais útil ter mais de duas conexões em uma porta AND.
</p>
<p> Agora adicionaremos as outras portas. Primeiro clique sobre a porta OR
(<img src="../../icons/orGate.gif" width="16" height="16">);
em seguida, clique onde você quiser colocá-la. E coloque também duas portas NOT
buscando-as em (<img src="../../icons/notGate.gif" width="16" height="16">).
</p>
<center> <img src="shot-gates.png" width="473" height="247"> </center>
<p> Deixei um pouco de espaço entre as portas NOT e as portas AND, se você
quisero, porém, poderá colocá-las umas junto às outrss e poupar
o esforço de conectá-las por um fio mais tarde. </p>
<p> Agora queremos adicionar as duas entradas <var> x </var> e <var> y </var>
no diagrama. Selecione uma entrada
(<img src="../../icons/pinInput.gif" width="16" height="16">),
e coloque os pinos voltados para baixo.
Você também deverá colocar uma saída junto à porta OR, usando
(<img Src="../../icons/pinOutputReversed.gif" width="16" height="16">).
(Novamente, estou deixando um pouco de espaço entre a porta OR e a saída,
mas você poderá optar por colocá-las uma ao lado da outra.) </p>
<center> <img src="shot-comps.png" width="473" height="247"> </center>
<p> Se você achar que não gosta de onde colocou alguma coisa, poderá
selecioná-la usando a ferramenta Editar
(<img src="../../icons/select.gif" width="16" height="16">)
e arrastá-la para o local desejado. Ou ainda poderá excluí-la totalmente,
selecionando Excluir no menu Editar ou pressionar a tecla Delete.
</p>
<p> Quando você colocar cada componente do circuito, você verá que, logo que
ele for colocado, o Logisim reverte para a ferramenta Editar para que possa
mover o componente recém-colocado ou (como veremos em breve) conectar o componente
a outros, usando fios. Se quiser acrescentar uma cópia do recém-colocado
componente, um atalho é pressionar Control-D para duplicar a seleção.
(Alguns computadores usam outra teclas para menus, tais como a tecla de comando no
Macintosh. Você irá pressionar essa tecla junto com a tecla D).
</p>
<p><b>Próximo:</b> <a href="tutor-wires.html">Passo 2: Acrescentar conexões</a></p>
</body>
</html>

74
doc/pt/html/guide/tutorial/tutor-orient.html
View File

@ -1,37 +1,37 @@
<html>
<head>
<title>Tutorial: Orientar-se</title>
</head>
<body bgcolor="FFFFFF">
<p><b>Próximo:</b> <a href="tutor-gates.html">Passo 1: Acrescentar portas</a></p>
<h2>Passo 0: Orientar-se</h2>
<p> Quando você iniciar o Logisim, você verá uma janela semelhante à seguinte.
Alguns dos detalhes poderão ser ligeiramente diferentes, pois você estará
provavelmente usando um sistema diferente do meu. </p>
<center> <img src="shot-blank.png" width="473" height="247"> </center>
<p> O Logisim é dividido em três partes, chamada de <em> painel do explorador</em>,
<em> tabela de atributos</em>, e <em> área de desenho (ou tela)</em>. Acima dessas
estarão <em> a barra de menu </em> e <em> a barra de ferramentas</em>.
</p>
<center> <img src="shot-labeled.png" width="473" height="247"> </center>
<p> Poderemos eliminar rapidamente o painel do explorador e a tabela de atributo.
Não estaremos tratando delas neste tutorial, e você poderá simplesmente ignorá-las.
Além disso, a barra de menu é auto-explicativa.
</p>
<p> Isso nos deixará com a barra de ferramentas e a área de desenho (ou tela).
Esta última é onde você irá desenhar o circuito, e a barra de ferramentas contém
os itens que você poderá usar para fazer isso.
</p>
<p><b>Próximo:</b> <a href="tutor-gates.html">Passo 1: Acrescentar portas</a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Tutorial: Orientar-se</title>
</head>
<body bgcolor="FFFFFF">
<p><b>Próximo:</b> <a href="tutor-gates.html">Passo 1: Acrescentar portas</a></p>
<h2>Passo 0: Orientar-se</h2>
<p> Quando você iniciar o Logisim, você verá uma janela semelhante à seguinte.
Alguns dos detalhes poderão ser ligeiramente diferentes, pois você estará
provavelmente usando um sistema diferente do meu. </p>
<center> <img src="shot-blank.png" width="473" height="247"> </center>
<p> O Logisim é dividido em três partes, chamada de <em> painel do explorador</em>,
<em> tabela de atributos</em>, e <em> área de desenho (ou tela)</em>. Acima dessas
estarão <em> a barra de menu </em> e <em> a barra de ferramentas</em>.
</p>
<center> <img src="shot-labeled.png" width="473" height="247"> </center>
<p> Poderemos eliminar rapidamente o painel do explorador e a tabela de atributo.
Não estaremos tratando delas neste tutorial, e você poderá simplesmente ignorá-las.
Além disso, a barra de menu é auto-explicativa.
</p>
<p> Isso nos deixará com a barra de ferramentas e a área de desenho (ou tela).
Esta última é onde você irá desenhar o circuito, e a barra de ferramentas contém
os itens que você poderá usar para fazer isso.
</p>
<p><b>Próximo:</b> <a href="tutor-gates.html">Passo 1: Acrescentar portas</a></p>
</body>
</html>

122
doc/pt/html/guide/tutorial/tutor-test.html
View File

@ -1,61 +1,61 @@
<html>
<head>
<title>Tutorial: Testar seu circuito</title>
</head>
<body bgcolor="FFFFFF">
<p><b>Próximo:</b> <em><a href="../index.html">Guia do usuário</a></em></p>
<h2>Passo 4: Testar seu circuito</h2>
<p> Nosso passo final será testar o circuito para garantir que ele realmente
realiza o que pretendemos. O Logisim já está simulando o circuito. Vamos dar uma olhada
novamente aonde estávamos.
</p>
<center> <img src="shot-all.png" width="473" height="247"> </center>
<p> Observe que os pinos de entrada contêm zeros, e assim também o pino de saída.
Isso já nos diz que o circuito já calcula um 0 quando ambas as entradas são iguais a 0.
</p>
<p> Agora tentaremos outra combinação das entrada. Selecione a ferramenta Testar (Poke)
(<img src="../../icons/poke.gif" width="16" height="16">) e começaremos a alterar as
entradas, clicando sobre elas. Cada vez que fizer isso sobre a entrada, seu valor será
alternado. Por exemplo, poderíamos fazer isso.
</p>
<center> <img src="shot-test.png" width="473" height="247"> </center>
<p> Quando você mudar o valor de entrada, o Logisim irá mostrar-lhe que os valores
seguirão pelos fios marcando-os com a cor verde-claro para indicar um valor 1
ou verde-escuro (quase preto) para indicar um valor 0. Você também poderá ver
que o valor de saída foi alterado para 1.
</p>
<p> Até agora, nós testamos as duas primeiras linhas da nossa tabela-verdade, e as
saídas (0 e 1) corresponderão aos resultados desejados.
<center> <img src="xor-table.png" width="163" height="131"> </center>
Ao testar combinações diferentes, poderemos verificar as outras duas linhas.
Se todos elas corresponderem, então terminamos: o circuito funciona!
</p>
<br>
<p> Para arquivar o seu trabalho concluído, talvez você queira salvar ou imprimir
seu circuito. O menu Arquivo permitirá isso, e é claro que também lhe permitirá
sair do Logisim. Mas por que parar agora?
</p>
<p> Agora que você está terminando o tutorial, poderá experimentar o Logisim
construindo seus próprios circuitos. Se você quiser construir circuitos com recursos
mais sofisticados, então você deverá navegar através das outras opções
do sistema de ajuda para ver o que mais você poderá fazer. Logisim é
um programa poderoso, que lhe permitirá construir e testar circuitos maiores;
esse procedimento passo-a-passo apenas fez arranhões na superfície.
</p>
<p><b>Próximo:</b> <em><a href="../index.html">Guia do usuário</a></em></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Tutorial: Testar seu circuito</title>
</head>
<body bgcolor="FFFFFF">
<p><b>Próximo:</b> <em><a href="../index.html">Guia do usuário</a></em></p>
<h2>Passo 4: Testar seu circuito</h2>
<p> Nosso passo final será testar o circuito para garantir que ele realmente
realiza o que pretendemos. O Logisim já está simulando o circuito. Vamos dar uma olhada
novamente aonde estávamos.
</p>
<center> <img src="shot-all.png" width="473" height="247"> </center>
<p> Observe que os pinos de entrada contêm zeros, e assim também o pino de saída.
Isso já nos diz que o circuito já calcula um 0 quando ambas as entradas são iguais a 0.
</p>
<p> Agora tentaremos outra combinação das entrada. Selecione a ferramenta Testar (Poke)
(<img src="../../icons/poke.gif" width="16" height="16">) e começaremos a alterar as
entradas, clicando sobre elas. Cada vez que fizer isso sobre a entrada, seu valor será
alternado. Por exemplo, poderíamos fazer isso.
</p>
<center> <img src="shot-test.png" width="473" height="247"> </center>
<p> Quando você mudar o valor de entrada, o Logisim irá mostrar-lhe que os valores
seguirão pelos fios marcando-os com a cor verde-claro para indicar um valor 1
ou verde-escuro (quase preto) para indicar um valor 0. Você também poderá ver
que o valor de saída foi alterado para 1.
</p>
<p> Até agora, nós testamos as duas primeiras linhas da nossa tabela-verdade, e as
saídas (0 e 1) corresponderão aos resultados desejados.
<center> <img src="xor-table.png" width="163" height="131"> </center>
Ao testar combinações diferentes, poderemos verificar as outras duas linhas.
Se todos elas corresponderem, então terminamos: o circuito funciona!
</p>
<br>
<p> Para arquivar o seu trabalho concluído, talvez você queira salvar ou imprimir
seu circuito. O menu Arquivo permitirá isso, e é claro que também lhe permitirá
sair do Logisim. Mas por que parar agora?
</p>
<p> Agora que você está terminando o tutorial, poderá experimentar o Logisim
construindo seus próprios circuitos. Se você quiser construir circuitos com recursos
mais sofisticados, então você deverá navegar através das outras opções
do sistema de ajuda para ver o que mais você poderá fazer. Logisim é
um programa poderoso, que lhe permitirá construir e testar circuitos maiores;
esse procedimento passo-a-passo apenas fez arranhões na superfície.
</p>
<p><b>Próximo:</b> <em><a href="../index.html">Guia do usuário</a></em></p>
</body>
</html>

68
doc/pt/html/guide/tutorial/tutor-text.html
View File

@ -1,34 +1,34 @@
<html>
<head>
<title>Tutorial: Acrescentar texto</title>
</head>
<body bgcolor="FFFFFF">
<p><b>Próximo:</b> <a href="tutor-test.html">Passo 4: Testar seu circuito</a></p>
<h2>Passo 3: Acrescentar texto</h2>
<p> Acrescentar texto ao circuito não será necessário para fazê-lo funcionar;
mas se você quiser mostrar o seu circuito para alguém (como a um professor),
então, alguns rótulos ajudarão a comunicar os propósitos de diferentes partes
do seu circuito.
</p>
<p> Selecionar a ferramenta de texto
(<img src="../../icons/text.gif" width="16" height="16">).
</p>
<p> Você poderá clicar em um pino de entrada e começar a escrever para dar-lhe
um rótulo. (É melhor clicar diretamente no pino de entrada do que
clicar onde você quiser colocar o texto, porque o rótulo irá mover-se
junto com o pino).
Você poderá fazer o mesmo para o pino de saída. Ou você poderá simplesmente
clicar em qualquer outro lugar e começar a escrever para colocar um rótulo ali.
</p>
<center><img src="shot-all.png" width="473" height="247"></center></p>
<p><b>Próximo:</b> <a href="tutor-test.html">Passo 4: Testar seu circuito</a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Tutorial: Acrescentar texto</title>
</head>
<body bgcolor="FFFFFF">
<p><b>Próximo:</b> <a href="tutor-test.html">Passo 4: Testar seu circuito</a></p>
<h2>Passo 3: Acrescentar texto</h2>
<p> Acrescentar texto ao circuito não será necessário para fazê-lo funcionar;
mas se você quiser mostrar o seu circuito para alguém (como a um professor),
então, alguns rótulos ajudarão a comunicar os propósitos de diferentes partes
do seu circuito.
</p>
<p> Selecionar a ferramenta de texto
(<img src="../../icons/text.gif" width="16" height="16">).
</p>
<p> Você poderá clicar em um pino de entrada e começar a escrever para dar-lhe
um rótulo. (É melhor clicar diretamente no pino de entrada do que
clicar onde você quiser colocar o texto, porque o rótulo irá mover-se
junto com o pino).
Você poderá fazer o mesmo para o pino de saída. Ou você poderá simplesmente
clicar em qualquer outro lugar e começar a escrever para colocar um rótulo ali.
</p>
<center><img src="shot-all.png" width="473" height="247"></center></p>
<p><b>Próximo:</b> <a href="tutor-test.html">Passo 4: Testar seu circuito</a></p>
</body>
</html>

124
doc/pt/html/guide/tutorial/tutor-wires.html
View File

@ -1,62 +1,62 @@
<html>
<head>
<title>Tutorial: Acrescentar conexões</title>
</head>
<body bgcolor="FFFFFF">
<p><b>Próximo:</b> <a href="tutor-text.html">Passo 3: Acrescentar texto</a></p>
<h2>Passo 2: Acrescentar conexões</h2>
<p> Depois de ter todos os componentes colocados na área de desenho (tela),
você estará pronto para começar a adicionar as conexões.
</p>
<p> Selecionar a ferramenta Editar
(<img src="../../icons/select.gif" width="16" height="16">).
</p>
<p> Quando o cursor estiver sobre um ponto que receberá uma extremidade do fio,
um pequeno círculo verde será desenhado em torno dele. Pressione o botão do mouse e
arraste até onde você quiser que a outra extremidade do fio vá.
</p>
<p> O Logisim é bem inteligente ao adicionar conxões: sempre que um fio terminar em
outro, o Logisim automaticamente irá conectá-los. Você também poderá "estender" ou
"encurtar" uma conexão arrastando uma de suas extremidades do fio usando a ferramenta
de edição.
</p>
<p> As conexões (fios) em Logisim deverão ser horizontais ou verticais.
Para conectar entrada superior à porta NOT e à porta AND, em seguida, acrescentei
três fios. </p>
<center> <img src="shot-wire1.png" width="473" height="247"> </center>
<p> O Logisim automaticamente conectará os fios às portas
e uns aos outros. Isso inclui automaticamente o desenho do círculo sobre o
<em> T </em> da intersecção acima, indicando que os fios estão ligados.
</p>
<p> Ao traçar as conexões, você poderá ver alguns fios azuis ou cinzas. O azul no
Logisim indicará que o valor naquele ponto é "desconhecido", e cinza
indica que o fio não estará conectado a nada. Isso nã importa muito já que
você estará em processo de construção de um circuito. Mas quando você terminar,
nenhum de seus fios deverá ser azul ou cinza. (Os pontos desconectados da porta OR
ainda estarão azuis: isso é bom.)
</p>
<p> Se você tiver um fio azul ou cinza depois que você achar que tudo
já tiver sido conectado, então há algo de errado. É importante
que você conecte os fios nos lugares certos. O Logisim apresenta pontinhos
sobre os componentes para indicar onde os fios deverão se conectar. A medida em que
prosseguir, você verá que os pontos mudarão de azul para verde-claro ou escuro.
</p>
<p> Depois que tiver todos os fios conectados, todas as conexões que tenham sido
inseridas deverão estar em verde-claro ou escuro.
</p>
<center><img src="shot-wires.png" width="473" height="247"></center>
<p><b>Próximo:</b> <a href="tutor-text.html">Passo 3: Acrescentar texto</a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Tutorial: Acrescentar conexões</title>
</head>
<body bgcolor="FFFFFF">
<p><b>Próximo:</b> <a href="tutor-text.html">Passo 3: Acrescentar texto</a></p>
<h2>Passo 2: Acrescentar conexões</h2>
<p> Depois de ter todos os componentes colocados na área de desenho (tela),
você estará pronto para começar a adicionar as conexões.
</p>
<p> Selecionar a ferramenta Editar
(<img src="../../icons/select.gif" width="16" height="16">).
</p>
<p> Quando o cursor estiver sobre um ponto que receberá uma extremidade do fio,
um pequeno círculo verde será desenhado em torno dele. Pressione o botão do mouse e
arraste até onde você quiser que a outra extremidade do fio vá.
</p>
<p> O Logisim é bem inteligente ao adicionar conxões: sempre que um fio terminar em
outro, o Logisim automaticamente irá conectá-los. Você também poderá "estender" ou
"encurtar" uma conexão arrastando uma de suas extremidades do fio usando a ferramenta
de edição.
</p>
<p> As conexões (fios) em Logisim deverão ser horizontais ou verticais.
Para conectar entrada superior à porta NOT e à porta AND, em seguida, acrescentei
três fios. </p>
<center> <img src="shot-wire1.png" width="473" height="247"> </center>
<p> O Logisim automaticamente conectará os fios às portas
e uns aos outros. Isso inclui automaticamente o desenho do círculo sobre o
<em> T </em> da intersecção acima, indicando que os fios estão ligados.
</p>
<p> Ao traçar as conexões, você poderá ver alguns fios azuis ou cinzas. O azul no
Logisim indicará que o valor naquele ponto é "desconhecido", e cinza
indica que o fio não estará conectado a nada. Isso nã importa muito já que
você estará em processo de construção de um circuito. Mas quando você terminar,
nenhum de seus fios deverá ser azul ou cinza. (Os pontos desconectados da porta OR
ainda estarão azuis: isso é bom.)
</p>
<p> Se você tiver um fio azul ou cinza depois que você achar que tudo
já tiver sido conectado, então há algo de errado. É importante
que você conecte os fios nos lugares certos. O Logisim apresenta pontinhos
sobre os componentes para indicar onde os fios deverão se conectar. A medida em que
prosseguir, você verá que os pontos mudarão de azul para verde-claro ou escuro.
</p>
<p> Depois que tiver todos os fios conectados, todas as conexões que tenham sido
inseridas deverão estar em verde-claro ou escuro.
</p>
<center><img src="shot-wires.png" width="473" height="247"></center>
<p><b>Próximo:</b> <a href="tutor-text.html">Passo 3: Acrescentar texto</a></p>
</body>
</html>

160
doc/pt/html/guide/verify/index.html
View File

@ -1,80 +1,80 @@
<html>
<head>
<title>Verificação pela linha de comando</title>
</head>
<body bgcolor="FFFFFF">
<h1>Verificação pela linha de comando</h1>
<blockquote><em>Subseções:</em>
<br><a href="sub.html">Substituir bibliotecas</a>
<br><a href="other.html">Outras opções para verificação</a>
<br><a href="multi.html">Testar múltiplos arquivos</a>
</blockquote>
<p> O Logisim inclui suporte básico para a execução de circuitos a partir
da linha de comando.
Isso destina-se tanto para ajudar a verificação orientada de projetos de circuitos,
quanto para que instrutores realizem testes automatizados em soluções feitas por alunos.
</p>
<p> Vamos começar por mostrar como executar um circuito pela linha de comando.
Para o nosso exemplo, vamos supor que tenhamos construído o circuito a seguir
em um arquivo chamado <tt> adder-test.circ</tt>.
Ele utilizará um somador de dois bits como um subcircuito
e iterará através de um contador com todas as 16 possíveis entradas para ele.
</p>
<blockquote> <img src="adder-test.png" width="207" height="121"> </blockquote>
<p> Após esse circuito ter sido construído, executaremos a linha de comando do Logisim,
fornecendo o nome do projeto e a opção <q>-tty </q> opção com o parâmetro <q>table</q>.
</p>
<blockquote><tt>java -jar logisim-filename.jar adder-test.circ -tty table</tt></blockquote>
<p> Sem abrir qualquer janela, o Logisim carregará o circuito e começará a executá-lo,
variando qualquer <i>clock</i> tão rápido quanto possível até concluir a propagação
entre cada instante.
Após cada propagação ter sido concluída, o Logisim carregará os valores atuais dos
pinos de saída; caso tenham mudado na propagação anterior,
os valores serão exibidos em formato delimitado por tabulações.
Se houver um pino de saída marcado com a palavra especial <q> halt </q>,
sua saída não será exibida - mas uma vez que o valor do pino chegue a 1, depois
que uma propagação for concluída, o Logisim terminará a simulação.
</p>
<p> Para o nosso exemplo, o Logisim mostrará a tabela abaixo.
Por termos dois pinos de saída correspondentes às duas entradas <var> a </var> e
<var> b </var> para o somador de dois bits, essas saídas serão incluídas como
as duas primeiras colunas da saída.
E como há outro pino de saída correspondente no somador de dois bits, por isso,
haverá uma terceira coluna.
As colunas serão ordenadas da esquerda para a direita de acordo com a ordem
de cima para baixo dentro do circuito.
</p>
<blockquote><pre>
00 00 000
01 00 001
10 00 010
11 00 011
00 01 001
01 01 010
10 01 011
11 01 100
00 10 010
01 10 011
10 10 100
11 10 101
00 11 011
01 11 100
10 11 101
11 11 110
</pre></blockquote>
<p><strong>Próximo:</strong> <a href="sub.html">Substituir bibliotecas</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Verificação pela linha de comando</title>
</head>
<body bgcolor="FFFFFF">
<h1>Verificação pela linha de comando</h1>
<blockquote><em>Subseções:</em>
<br><a href="sub.html">Substituir bibliotecas</a>
<br><a href="other.html">Outras opções para verificação</a>
<br><a href="multi.html">Testar múltiplos arquivos</a>
</blockquote>
<p> O Logisim inclui suporte básico para a execução de circuitos a partir
da linha de comando.
Isso destina-se tanto para ajudar a verificação orientada de projetos de circuitos,
quanto para que instrutores realizem testes automatizados em soluções feitas por alunos.
</p>
<p> Vamos começar por mostrar como executar um circuito pela linha de comando.
Para o nosso exemplo, vamos supor que tenhamos construído o circuito a seguir
em um arquivo chamado <tt> adder-test.circ</tt>.
Ele utilizará um somador de dois bits como um subcircuito
e iterará através de um contador com todas as 16 possíveis entradas para ele.
</p>
<blockquote> <img src="adder-test.png" width="207" height="121"> </blockquote>
<p> Após esse circuito ter sido construído, executaremos a linha de comando do Logisim,
fornecendo o nome do projeto e a opção <q>-tty </q> opção com o parâmetro <q>table</q>.
</p>
<blockquote><tt>java -jar logisim-filename.jar adder-test.circ -tty table</tt></blockquote>
<p> Sem abrir qualquer janela, o Logisim carregará o circuito e começará a executá-lo,
variando qualquer <i>clock</i> tão rápido quanto possível até concluir a propagação
entre cada instante.
Após cada propagação ter sido concluída, o Logisim carregará os valores atuais dos
pinos de saída; caso tenham mudado na propagação anterior,
os valores serão exibidos em formato delimitado por tabulações.
Se houver um pino de saída marcado com a palavra especial <q> halt </q>,
sua saída não será exibida - mas uma vez que o valor do pino chegue a 1, depois
que uma propagação for concluída, o Logisim terminará a simulação.
</p>
<p> Para o nosso exemplo, o Logisim mostrará a tabela abaixo.
Por termos dois pinos de saída correspondentes às duas entradas <var> a </var> e
<var> b </var> para o somador de dois bits, essas saídas serão incluídas como
as duas primeiras colunas da saída.
E como há outro pino de saída correspondente no somador de dois bits, por isso,
haverá uma terceira coluna.
As colunas serão ordenadas da esquerda para a direita de acordo com a ordem
de cima para baixo dentro do circuito.
</p>
<blockquote><pre>
00 00 000
01 00 001
10 00 010
11 00 011
00 01 001
01 01 010
10 01 011
11 01 100
00 10 010
01 10 011
10 10 100
11 10 101
00 11 011
01 11 100
10 11 101
11 11 110
</pre></blockquote>
<p><strong>Próximo:</strong> <a href="sub.html">Substituir bibliotecas</a>.</p>
</body>
</html>

136
doc/pt/html/guide/verify/multi.html
View File

@ -1,68 +1,68 @@
<html>
<head>
<title>Testar múltiplos arquivos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Testar múltiplos arquivos</h1>
<p> Em um exemplo de sala de aula, você poderá ter vários arquivos que deseje testar
a equivalência, e você pode não querer ler as saídas para cada uma das soluções do aluno.
</p>
<h2> Construir comparações de circuito </h2>
<p> Uma abordagem é a construir um circuito para testes que fará a comparação direta.
Criaremos um circuito adicional no arquivo para testes que conterá
nosso circuito com a solução. Nosso circuito de teste global, incluirá o
subcircuito <tt> adder-master.circ </tt> e o subcircuio com solução
acoplados em um mesmo circuito. Conexões serão feitas para que haja
apenas uma saída, que será 1, quando os dois subcircuitos concordarem.
</p>
<blockquote><img src="adder-test2.png" width="264" height="92"></blockquote>
<p> Agora podemos simplesmente executar o Logisim substituindo cada arquivo de consulta.
Para qualquer solução correta, haverá uma única saída igual a <q> 1 </q>.
</p>
<h2> Usar redirecionamento e shell scripts </h2>
<p> Se você estiver completamente confortável com a linha de comando,
você poderá construir seu próprio <i>shell script</i> para fazer isso.
Aqui, vamos usar o redirecionamento (o operador>) para salvar a saída de cada
circuito em um arquivo.
Por exemplo, poderíamos emitir os seguintes comandos para coletar a saída
do circuito principal e do circuito de consulta.
<blockquote><tt>java&nbsp;-jar&nbsp;logisim-filename.jar&nbsp;adder-test.circ&nbsp;-tty&nbsp;table&nbsp;&gt;&nbsp;output-master.txt
<br>java&nbsp;-jar&nbsp;logisim-filename.jar&nbsp;adder-test.circ&nbsp;-tty&nbsp;table&nbsp;-sub&nbsp;adder-master.circ&nbsp;adder-query.circ&nbsp;&gt;&nbsp;output-query.txt</tt></blockquote>
<p> Agora teremos criado dois arquivos diferentes.
Poderemos então comparar os dois arquivos de saída usando um programa construído para esse fim.
Em Linux ou MacOS X, você poderá usar o <em> cmp </em> ou <em> diff </em>
utilitários de linha de comando. No Windows, você poderá usar o WinMerge.
</p>
<p> Para processar vários arquivos de consulta, você poderá construir um programa simples
como um <i> script shell</i> para percorrer cada um e comparar o resultado.
Aqui está como eu faria isso no Linux com <em> bash </em>
</p>
<blockquote><tt>RUN_TEST="java&nbsp;-jar&nbsp;logisim-filename.jar&nbsp;adder-test.circ&nbsp;-tty&nbsp;table"<br>
${RUN_TEST}&nbsp;&gt;&nbsp;output-master.txt<br>
for&nbsp;QUERY_FILE&nbsp;in&nbsp;adder-query*.circ<br>
do<br>
&nbsp;&nbsp;if&nbsp;${RUN_TEST}&nbsp;-sub&nbsp;adder-master.circ&nbsp;${QUERY_FILE}&nbsp;|&nbsp;cmp&nbsp;-s&nbsp;output-master.txt<br>
&nbsp;&nbsp;then<br>
&nbsp;&nbsp;&nbsp;&nbsp;echo&nbsp;"${QUERY_FILE}&nbsp;OK"<br>
&nbsp;&nbsp;else<br>
&nbsp;&nbsp;&nbsp;&nbsp;echo&nbsp;"${QUERY_FILE}&nbsp;different"<br>
&nbsp;&nbsp;fi<br>
done</tt></blockquote>
<p><strong>Próximo:</strong> <em><a href="../index.html"><em>Guia do usuário</em></a></em>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Testar múltiplos arquivos</title>
</head>
<body bgcolor="FFFFFF">
<h1>Testar múltiplos arquivos</h1>
<p> Em um exemplo de sala de aula, você poderá ter vários arquivos que deseje testar
a equivalência, e você pode não querer ler as saídas para cada uma das soluções do aluno.
</p>
<h2> Construir comparações de circuito </h2>
<p> Uma abordagem é a construir um circuito para testes que fará a comparação direta.
Criaremos um circuito adicional no arquivo para testes que conterá
nosso circuito com a solução. Nosso circuito de teste global, incluirá o
subcircuito <tt> adder-master.circ </tt> e o subcircuio com solução
acoplados em um mesmo circuito. Conexões serão feitas para que haja
apenas uma saída, que será 1, quando os dois subcircuitos concordarem.
</p>
<blockquote><img src="adder-test2.png" width="264" height="92"></blockquote>
<p> Agora podemos simplesmente executar o Logisim substituindo cada arquivo de consulta.
Para qualquer solução correta, haverá uma única saída igual a <q> 1 </q>.
</p>
<h2> Usar redirecionamento e shell scripts </h2>
<p> Se você estiver completamente confortável com a linha de comando,
você poderá construir seu próprio <i>shell script</i> para fazer isso.
Aqui, vamos usar o redirecionamento (o operador>) para salvar a saída de cada
circuito em um arquivo.
Por exemplo, poderíamos emitir os seguintes comandos para coletar a saída
do circuito principal e do circuito de consulta.
<blockquote><tt>java&nbsp;-jar&nbsp;logisim-filename.jar&nbsp;adder-test.circ&nbsp;-tty&nbsp;table&nbsp;&gt;&nbsp;output-master.txt
<br>java&nbsp;-jar&nbsp;logisim-filename.jar&nbsp;adder-test.circ&nbsp;-tty&nbsp;table&nbsp;-sub&nbsp;adder-master.circ&nbsp;adder-query.circ&nbsp;&gt;&nbsp;output-query.txt</tt></blockquote>
<p> Agora teremos criado dois arquivos diferentes.
Poderemos então comparar os dois arquivos de saída usando um programa construído para esse fim.
Em Linux ou MacOS X, você poderá usar o <em> cmp </em> ou <em> diff </em>
utilitários de linha de comando. No Windows, você poderá usar o WinMerge.
</p>
<p> Para processar vários arquivos de consulta, você poderá construir um programa simples
como um <i> script shell</i> para percorrer cada um e comparar o resultado.
Aqui está como eu faria isso no Linux com <em> bash </em>
</p>
<blockquote><tt>RUN_TEST="java&nbsp;-jar&nbsp;logisim-filename.jar&nbsp;adder-test.circ&nbsp;-tty&nbsp;table"<br>
${RUN_TEST}&nbsp;&gt;&nbsp;output-master.txt<br>
for&nbsp;QUERY_FILE&nbsp;in&nbsp;adder-query*.circ<br>
do<br>
&nbsp;&nbsp;if&nbsp;${RUN_TEST}&nbsp;-sub&nbsp;adder-master.circ&nbsp;${QUERY_FILE}&nbsp;|&nbsp;cmp&nbsp;-s&nbsp;output-master.txt<br>
&nbsp;&nbsp;then<br>
&nbsp;&nbsp;&nbsp;&nbsp;echo&nbsp;"${QUERY_FILE}&nbsp;OK"<br>
&nbsp;&nbsp;else<br>
&nbsp;&nbsp;&nbsp;&nbsp;echo&nbsp;"${QUERY_FILE}&nbsp;different"<br>
&nbsp;&nbsp;fi<br>
done</tt></blockquote>
<p><strong>Próximo:</strong> <em><a href="../index.html"><em>Guia do usuário</em></a></em>.</p>
</body>
</html>

216
doc/pt/html/guide/verify/other.html
View File

@ -1,108 +1,108 @@
<html>
<head>
<title>Outras opções para verificação</title>
</head>
<body bgcolor="FFFFFF">
<h1>Outras opções para verificação</h1>
<p> Existem algumas opções adicionais relacionadas com a execução pela linha de comandos.
</p>
<h2> O parâmetro <tt> -load </tt> na linha de comando </h2>
<p> Um circuito mais complexo poderá incluir um componente de memória RAM que precisará
ser carregado com um programa para que o circuito possa usá-lo.
Você poderá especificar um arquivo de imagem da memória na linha de comando,
que será carregado em qualquer componente de RAM no circuito antes da simulação começar.
(Isso não funcionará quando se carregar a interface gráfica - só servirá para a
execução de linha de comando.)
</p>
<blockquote><tt>java -jar logisim-filename.jar cpu.circ -tty table -load mem-image.txt</tt></blockquote>
<p> A ordem dos parâmetros não é importante (exceto para o parâmetro <tt> table </tt>
que deverá ser imediatamente após <tt>-tty </tt>, e o nome do arquivo de imagem da
memória que deverá ser logo após <tt>-load </tt>).
O arquivo de imagem deverá estar no <a href="../mem/menu.html"> formato de imagem da
memória do Logisim </a>.
</p>
<p> O Logisim pesquisará pela RAM recursivamente, de modo que esse continuará a
funcionar mesmo se a RAM estiver embutida em um subcircuito.
Não há maneira alguma, no entanto, de distinguir diferentes componentes do tipo RAM:
o Logisim irá tentar carregar o mesmo arquivo em todas as RAMs que puder encontrar.
</p>
<h2> Opções para o parâmetro <tt>-tty </tt> </h2>
<p> Em nossos exemplos até agora, sempre usamos tabela <q><tt>-tty&nbsp;table</tt></q>
para indicar que uma tabela de valores de saída deverá ser exibida. Você poderá
personalizar o comportamento de outras formas, listando uma ou mais opções,
separados por vírgulas. Por exemplo, você poderá escrever
<q><tt>-tty&nbsp;table,halt,speed</tt></q>,
e o programa irá executar todas os três comportamentos listados abaixo.
(A ordem em que estão listados não importa.)
</p>
<dl>
<dt> <tt> halt </tt> </dt>
<dd> <p> Após a simulação terminar, aparecerá uma mensagem de uma linha
explicando porque a simulação terminou. Condições de erro - como uma oscilação detectada -
serão exibidas em qualquer caso.
</p> </dd>
<dt> <tt> speed </tt> </dt>
<dd> <p> Se você usar essa opção em conjunto com <q> <tt>-tty </tt> </q>,
em seguida, depois que completar a simulação o Logisim irá exibir um resumo de
quão rápido o circuito foi simulado, tal como:
</p>
<blockquote><tt>714 Hz (509 ticks in 712 milliseconds)</tt></blockquote>
<p> Observar que a exibição de informações durante a simulação
fará a simulação ser muito mais lento. Como apenas uma comparação,
para o mesmo circuito e imagem funcionou acima de 714 Hz com a opção <tt> speed </tt>
e apenas a 490 Hz com a opção <tt>table</tt> também.
</p> </dd>
<dt> <tt> statistics </tt> </dt>
<dd> <p> Mostrar uma tabela delimitada por tabulações contendo dados estatísticos
sobre os componentes utilizados pelo circuito <q> principal </q> no projeto.
A tabela inclui quatro colunas:
</p>
<ul>
<li> Exclusiva: O número de vezes que o componente aparecer na hierarquia do circuito,
onde cada subcircuito dentro da hierarquia será contabilizado apenas uma vez. </li>
<li> Recursiva: O número de vezes que o componente aparecer na hierarquia do circuito,
onde contamos cada subcircuito quantas vezes ele aparecer na hierarquia. </li>
<li> Componente: O nome do componente </li>
<li> Biblioteca: O nome da biblioteca a partir do qual o componente veio </li>
</ul>
<p> A distinção entre <q> exclusiva </q> e <q> recursiva </q> também está explicada
na seção <q> <a href="../menu/project.html"> menu de Projeto </a> </q>.
Se o arquivo utilizar circuitos de uma biblioteca carregada do Logisim,
os componentes serão considerado <q> caixas pretas </q>: o conteúdo dos circuitos
da biblioteca não serão incluídos na contagem exclusiva ou recursiva. </p>
<p> (Esse recurso pode ser útil para os instrutores que peçam aos alunos para criar
projetos com um subconjunto de bibliotecas de Logisim.)
</p> </dd>
<dt> <tt> table </tt> </dt>
<dd> <p> (já visto) </p> </dd>
<dt> <tt> tty </tt> </dt>
<dd> <p> Quaisquer componentes TTY enviarão suas saída para a tela (saída padrão),
e todas as informações digitadas no teclado serão enviadas para todos os
equivalentes no circuito.
Esses componentes serão incluídos, mesmo que sejam profundamente aninhados
à hierarquia do subcircuito.
</p> </dd>
<p><strong>Próximo:</strong>&nbsp;<a href="multi.html">Testar múltiplos arquivos</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Outras opções para verificação</title>
</head>
<body bgcolor="FFFFFF">
<h1>Outras opções para verificação</h1>
<p> Existem algumas opções adicionais relacionadas com a execução pela linha de comandos.
</p>
<h2> O parâmetro <tt> -load </tt> na linha de comando </h2>
<p> Um circuito mais complexo poderá incluir um componente de memória RAM que precisará
ser carregado com um programa para que o circuito possa usá-lo.
Você poderá especificar um arquivo de imagem da memória na linha de comando,
que será carregado em qualquer componente de RAM no circuito antes da simulação começar.
(Isso não funcionará quando se carregar a interface gráfica - só servirá para a
execução de linha de comando.)
</p>
<blockquote><tt>java -jar logisim-filename.jar cpu.circ -tty table -load mem-image.txt</tt></blockquote>
<p> A ordem dos parâmetros não é importante (exceto para o parâmetro <tt> table </tt>
que deverá ser imediatamente após <tt>-tty </tt>, e o nome do arquivo de imagem da
memória que deverá ser logo após <tt>-load </tt>).
O arquivo de imagem deverá estar no <a href="../mem/menu.html"> formato de imagem da
memória do Logisim </a>.
</p>
<p> O Logisim pesquisará pela RAM recursivamente, de modo que esse continuará a
funcionar mesmo se a RAM estiver embutida em um subcircuito.
Não há maneira alguma, no entanto, de distinguir diferentes componentes do tipo RAM:
o Logisim irá tentar carregar o mesmo arquivo em todas as RAMs que puder encontrar.
</p>
<h2> Opções para o parâmetro <tt>-tty </tt> </h2>
<p> Em nossos exemplos até agora, sempre usamos tabela <q><tt>-tty&nbsp;table</tt></q>
para indicar que uma tabela de valores de saída deverá ser exibida. Você poderá
personalizar o comportamento de outras formas, listando uma ou mais opções,
separados por vírgulas. Por exemplo, você poderá escrever
<q><tt>-tty&nbsp;table,halt,speed</tt></q>,
e o programa irá executar todas os três comportamentos listados abaixo.
(A ordem em que estão listados não importa.)
</p>
<dl>
<dt> <tt> halt </tt> </dt>
<dd> <p> Após a simulação terminar, aparecerá uma mensagem de uma linha
explicando porque a simulação terminou. Condições de erro - como uma oscilação detectada -
serão exibidas em qualquer caso.
</p> </dd>
<dt> <tt> speed </tt> </dt>
<dd> <p> Se você usar essa opção em conjunto com <q> <tt>-tty </tt> </q>,
em seguida, depois que completar a simulação o Logisim irá exibir um resumo de
quão rápido o circuito foi simulado, tal como:
</p>
<blockquote><tt>714 Hz (509 ticks in 712 milliseconds)</tt></blockquote>
<p> Observar que a exibição de informações durante a simulação
fará a simulação ser muito mais lento. Como apenas uma comparação,
para o mesmo circuito e imagem funcionou acima de 714 Hz com a opção <tt> speed </tt>
e apenas a 490 Hz com a opção <tt>table</tt> também.
</p> </dd>
<dt> <tt> statistics </tt> </dt>
<dd> <p> Mostrar uma tabela delimitada por tabulações contendo dados estatísticos
sobre os componentes utilizados pelo circuito <q> principal </q> no projeto.
A tabela inclui quatro colunas:
</p>
<ul>
<li> Exclusiva: O número de vezes que o componente aparecer na hierarquia do circuito,
onde cada subcircuito dentro da hierarquia será contabilizado apenas uma vez. </li>
<li> Recursiva: O número de vezes que o componente aparecer na hierarquia do circuito,
onde contamos cada subcircuito quantas vezes ele aparecer na hierarquia. </li>
<li> Componente: O nome do componente </li>
<li> Biblioteca: O nome da biblioteca a partir do qual o componente veio </li>
</ul>
<p> A distinção entre <q> exclusiva </q> e <q> recursiva </q> também está explicada
na seção <q> <a href="../menu/project.html"> menu de Projeto </a> </q>.
Se o arquivo utilizar circuitos de uma biblioteca carregada do Logisim,
os componentes serão considerado <q> caixas pretas </q>: o conteúdo dos circuitos
da biblioteca não serão incluídos na contagem exclusiva ou recursiva. </p>
<p> (Esse recurso pode ser útil para os instrutores que peçam aos alunos para criar
projetos com um subconjunto de bibliotecas de Logisim.)
</p> </dd>
<dt> <tt> table </tt> </dt>
<dd> <p> (já visto) </p> </dd>
<dt> <tt> tty </tt> </dt>
<dd> <p> Quaisquer componentes TTY enviarão suas saída para a tela (saída padrão),
e todas as informações digitadas no teclado serão enviadas para todos os
equivalentes no circuito.
Esses componentes serão incluídos, mesmo que sejam profundamente aninhados
à hierarquia do subcircuito.
</p> </dd>
<p><strong>Próximo:</strong>&nbsp;<a href="multi.html">Testar múltiplos arquivos</a>.</p>
</body>
</html>

166
doc/pt/html/guide/verify/sub.html
View File

@ -1,83 +1,83 @@
<html>
<head>
<title>Substituir bibliotecas</title>
</head>
<body bgcolor="FFFFFF">
<h1>Substituir bibliotecas</h1>
<p> Agora suponha que tenhamos dois circuitos do Logisim que deveriam fazer a mesma coisa.
Como instrutor, você poderia ter pedido aos seus alunos concluírem uma tarefa.
Você tem um arquivo que contém sua solução, mas também vários arquivos de alunos
contendo seus trabalhos. Talvez a tarefa tenha sido construir um somador de dois bits.
</p>
<p> Imaginarei dois arquivos, chamados <tt> adder-master.circ </tt>
e <tt> adder-query.circ</tt>. Cada arquivo conterá um circuito chamado
<q> 2-bit adder </q> (é importante que o circuito para teste seja chamado
exatamente igual), cuja aparência poderá ser a seguinte.
</p>
<blockquote><table><tbody>
<tr><td><tt>adder-master.circ</tt></td>
<td><tt>adder-query.circ</tt></td></tr>
<tr><td><img src="adder-master.png" width="164" height="53"></td>
<td><img src="adder-query.png" width="171" height="92"></td></tr>
</tbody></table></blockquote>
<p> Como você poderá ver, o circuito principal usará o somador predefinido no Logisim,
enquanto o circuito para teste usará dois subcircuitos representando uma meia-soma e
uma soma-completa (os quais serão constituídos apenas por portas simples).
Para os fins do nosso exemplo, o circuito para teste terá um erro estúpido:
O <i>carry</i> da meia-soma não estará conectado à soma completa.
</p>
<p> Nós construíremos o nosso circuito de teste em um arquivo diferente.
Lá, carregaremos <tt> adder-master.circ </tt> como uma biblioteca do Logisim
(Projeto > Carregar Biblioteca > Biblioteca do Logisim ...), e inserir seu
somador de 2 bits como um subcircuito. Nós poderíamos executar esse circuito
diretamente para obter a saída desejada para uma solução perfeita.
</p>
<blockquote><tt>java&nbsp;-jar&nbsp;logisim-filename.jar&nbsp;adder-test.circ&nbsp;-tty&nbsp;table</tt></blockquote>
<p> Mas queremos executar o circuito usando <tt> adder-query.circ </tt>
ao invés de <tt> adder-master.circ </tt> como o da biblioteca carregada.
A abordagem ingênua seria abrir Logisim e carregar essa biblioteca de uma vez;
ou você poderá simplesmente remover o <tt> adder-master.circ </tt> e renomear
<tt> adder-query.circ </tt> para ser chamado de <tt> adder-master.circ </tt> em vez disso.
Mas Logisim inclui uma prática opção <q> <tt> sub </tt> </q> que substituirá
temporariamente um arquivo por outro durante a sessão - sem fazer quaisquer
alterações em disco.
</p>
<blockquote><tt>java&nbsp;-jar&nbsp;logisim-filename.jar&nbsp;adder-test.circ&nbsp;-tty&nbsp;table&nbsp;-sub&nbsp;adder-master.circ&nbsp;adder-query.circ</tt></blockquote>
<p> A saída que você iria ver a partir disso é mostrada abaixo, naturalmente é diferente
daquela vista na <a href="index.html"> seção anterior</a> já que agora será a
execução usando o <tt> adder-query.circ </tt> errado.
</p>
<blockquote>
<pre>
00 00 0E0
01 00 0E1
10 00 EE0
11 00 EE1
00 01 0E1
01 01 0E0
10 01 EE1
11 01 EE0
00 10 EE0
01 10 EE1
10 10 1E0
11 10 1E1
00 11 EE1
01 11 EE0
10 11 1E1
11 11 1E0
</pre></blockquote>
<p><strong>Próximo:</strong>&nbsp;<a href="other.html">Outras opções para verificações</a>.</p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Substituir bibliotecas</title>
</head>
<body bgcolor="FFFFFF">
<h1>Substituir bibliotecas</h1>
<p> Agora suponha que tenhamos dois circuitos do Logisim que deveriam fazer a mesma coisa.
Como instrutor, você poderia ter pedido aos seus alunos concluírem uma tarefa.
Você tem um arquivo que contém sua solução, mas também vários arquivos de alunos
contendo seus trabalhos. Talvez a tarefa tenha sido construir um somador de dois bits.
</p>
<p> Imaginarei dois arquivos, chamados <tt> adder-master.circ </tt>
e <tt> adder-query.circ</tt>. Cada arquivo conterá um circuito chamado
<q> 2-bit adder </q> (é importante que o circuito para teste seja chamado
exatamente igual), cuja aparência poderá ser a seguinte.
</p>
<blockquote><table><tbody>
<tr><td><tt>adder-master.circ</tt></td>
<td><tt>adder-query.circ</tt></td></tr>
<tr><td><img src="adder-master.png" width="164" height="53"></td>
<td><img src="adder-query.png" width="171" height="92"></td></tr>
</tbody></table></blockquote>
<p> Como você poderá ver, o circuito principal usará o somador predefinido no Logisim,
enquanto o circuito para teste usará dois subcircuitos representando uma meia-soma e
uma soma-completa (os quais serão constituídos apenas por portas simples).
Para os fins do nosso exemplo, o circuito para teste terá um erro estúpido:
O <i>carry</i> da meia-soma não estará conectado à soma completa.
</p>
<p> Nós construíremos o nosso circuito de teste em um arquivo diferente.
Lá, carregaremos <tt> adder-master.circ </tt> como uma biblioteca do Logisim
(Projeto > Carregar Biblioteca > Biblioteca do Logisim ...), e inserir seu
somador de 2 bits como um subcircuito. Nós poderíamos executar esse circuito
diretamente para obter a saída desejada para uma solução perfeita.
</p>
<blockquote><tt>java&nbsp;-jar&nbsp;logisim-filename.jar&nbsp;adder-test.circ&nbsp;-tty&nbsp;table</tt></blockquote>
<p> Mas queremos executar o circuito usando <tt> adder-query.circ </tt>
ao invés de <tt> adder-master.circ </tt> como o da biblioteca carregada.
A abordagem ingênua seria abrir Logisim e carregar essa biblioteca de uma vez;
ou você poderá simplesmente remover o <tt> adder-master.circ </tt> e renomear
<tt> adder-query.circ </tt> para ser chamado de <tt> adder-master.circ </tt> em vez disso.
Mas Logisim inclui uma prática opção <q> <tt> sub </tt> </q> que substituirá
temporariamente um arquivo por outro durante a sessão - sem fazer quaisquer
alterações em disco.
</p>
<blockquote><tt>java&nbsp;-jar&nbsp;logisim-filename.jar&nbsp;adder-test.circ&nbsp;-tty&nbsp;table&nbsp;-sub&nbsp;adder-master.circ&nbsp;adder-query.circ</tt></blockquote>
<p> A saída que você iria ver a partir disso é mostrada abaixo, naturalmente é diferente
daquela vista na <a href="index.html"> seção anterior</a> já que agora será a
execução usando o <tt> adder-query.circ </tt> errado.
</p>
<blockquote>
<pre>
00 00 0E0
01 00 0E1
10 00 EE0
11 00 EE1
00 01 0E1
01 01 0E0
10 01 EE1
11 01 EE0
00 10 EE0
01 10 EE1
10 10 1E0
11 10 1E1
00 11 EE1
01 11 EE0
10 11 1E1
11 11 1E0
</pre></blockquote>
<p><strong>Próximo:</strong>&nbsp;<a href="other.html">Outras opções para verificações</a>.</p>
</body>
</html>

32
doc/pt/html/index.html
View File

@ -1,16 +1,16 @@
<html>
<head>
<title>Bem vindo ao Logisim!</title>
</head>
<body bgcolor="FFFFFF">
<h1>Bem vindo ao Logisim!</h1>
<p>Unidades do sistema de ajuda do Logisim contêm:
<blockquote><em><a href="guide/index.html">Guia para se tornar usuário do Logisim</a></em>
<br><em><a href="libs/index.html">Referências para bibliotecas</a></em>
</blockquote></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Bem vindo ao Logisim!</title>
</head>
<body bgcolor="FFFFFF">
<h1>Bem vindo ao Logisim!</h1>
<p>Unidades do sistema de ajuda do Logisim contêm:
<blockquote><em><a href="guide/index.html">Guia para se tornar usuário do Logisim</a></em>
<br><em><a href="libs/index.html">Referências para bibliotecas</a></em>
</blockquote></p>
</body>
</html>

178
doc/pt/html/libs/arith/adder.html
View File

@ -1,89 +1,89 @@
<html>
<head>
<title>Somador</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/adder.gif" width="32" height="32">
<em>Somador</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 11</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/adder.png" width="44" height="45"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Esse componente adicionará dois valores que vierem através das entradas a oeste e
fornecerá a soma na saída a leste. O componente é projetado de modo a poder ser
conectado a outros somadores para tratar mais bits que os possíveis para um
único somador. A entrada <i>carry-in</i> fornecerá um valor de um bit para ser adicionado ao
montante (se for especificado), e a saída <i>carry-out</i> fornecerá um valor de um bit
correspondente ao valor de <i>overflow</i> (transbordamento) que poderá ser enviado a
outro componente.
</p>
<p> Se qualquer um dos adendos contiver algum bit flutuante ou erro, então
o componente irá executar uma adição parcial. Ou seja, ele irá calcular com
tantos bits de mais baixa ordem quanto possível. Mas, acima do bit flutuante
ou de erro, o resultado terá bits flutuantes ou de erro.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, norte final (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Um dos dois valores a serem somados.
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O outro dos dois valores a serem somados.
<dt> Na face norte, marcado <var> c in </var> (entrada, com largura de 1 bit)
<dd> Valor do <i>carry-in</i> a ser acrescentado à soma. Se o valor for desconhecido
(ou seja, flutuante), então será considerado como igual 0.
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits de mais baixa ordem dos <var> Bits de Dados </var> da soma dos dois valores
que vierem da face oeste, mais o bit de <var>c</var><sub><var>in</var></sub>.
<dt> Na face sul, marcado <var> c out </var> (saída, com largura de 1 bit)
<dd> O valor de <i>carry-out</i> calculado para a soma. Se os valores sem sinais somados
produzirem um resultado que caiba nos <var> Bits de Dados </var>,
então, esse bit será 0, caso contrário, será 1.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados </dt>
<dd> A largura em bits dos valores a serem adicionados e também do resultado.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Somador</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/adder.gif" width="32" height="32">
<em>Somador</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 11</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/adder.png" width="44" height="45"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Esse componente adicionará dois valores que vierem através das entradas a oeste e
fornecerá a soma na saída a leste. O componente é projetado de modo a poder ser
conectado a outros somadores para tratar mais bits que os possíveis para um
único somador. A entrada <i>carry-in</i> fornecerá um valor de um bit para ser adicionado ao
montante (se for especificado), e a saída <i>carry-out</i> fornecerá um valor de um bit
correspondente ao valor de <i>overflow</i> (transbordamento) que poderá ser enviado a
outro componente.
</p>
<p> Se qualquer um dos adendos contiver algum bit flutuante ou erro, então
o componente irá executar uma adição parcial. Ou seja, ele irá calcular com
tantos bits de mais baixa ordem quanto possível. Mas, acima do bit flutuante
ou de erro, o resultado terá bits flutuantes ou de erro.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, norte final (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Um dos dois valores a serem somados.
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O outro dos dois valores a serem somados.
<dt> Na face norte, marcado <var> c in </var> (entrada, com largura de 1 bit)
<dd> Valor do <i>carry-in</i> a ser acrescentado à soma. Se o valor for desconhecido
(ou seja, flutuante), então será considerado como igual 0.
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits de mais baixa ordem dos <var> Bits de Dados </var> da soma dos dois valores
que vierem da face oeste, mais o bit de <var>c</var><sub><var>in</var></sub>.
<dt> Na face sul, marcado <var> c out </var> (saída, com largura de 1 bit)
<dd> O valor de <i>carry-out</i> calculado para a soma. Se os valores sem sinais somados
produzirem um resultado que caiba nos <var> Bits de Dados </var>,
então, esse bit será 0, caso contrário, será 1.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados </dt>
<dd> A largura em bits dos valores a serem adicionados e também do resultado.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

164
doc/pt/html/libs/arith/bitadder.html
View File

@ -1,82 +1,82 @@
<html>
<head>
<title>Contador de Bits</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/bitadder.gif" width="32" height="32">
<em>Contador de Bits</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.6.0</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/bitadder.png" width="44" height="42"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> O componente determinará quantos bits em 1 estão em sua(s) entrada(s) e emitirá o
número total de bits em 1 em sua saída. Por exemplo, para a entrada de 8 bits 10011101,
a saída será a 5, uma vez que há cinco bits 1 na entrada (o primeiro, o último,
e uma sequência de três bits no meio).
</p>
<p> Se qualquer um dos bits de entrada for um valor flutuante ou erro, então a saída
conterá bits de erro na saída correspondente à faixa de saídas possíveis
dependendo se os valores de erro/flutuante forem contados como zeros ou uns.
Por exemplo, se a entrada de 14 bits for 111x10110x1101, a saída deve ser
pelo menos 9 (se cada "x" for interpretado como zero)
e no máximo 11 (se eles forem interpretados como um).
Assim, a saída será 10EE: os dois bits mais significativos serão 1 e 0, pois todos
os inteiros entre 9 e 11 têm 1 e 0 como seus dois primeiros bits, mas os dois últimos
bits serão EE já que os inteiros entre 9 e 11 variam dentro desses limites.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste (entradas, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> As entradas cujos bits em 1 serão contados. O número de entradas será baseado
no atributo Número de Entradas. </dd>
<dt> Na face leste (saída, com largura en bits calculada conforme descrito abaixo) </dt>
<dd> O número de bits de entrada iguais a 1. A largura em bits na saída será o
número mínimo de bits para armazenar o maior valor possível (que seria
o produto do atributo Bits de Dados pelo atributo Número de Entradas). </dd>
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
os dígito de '0' a '9' poderão alterar seu atributo <q>Número de Entradas</q> e
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
<dl>
<dt> Bits de dados </dt>
<dd> Largura em bits da(s) entrada(s).</dd>
<dt> Número de Entradas </dt>
<dd> Número de valores de entrada.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Contador de Bits</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/bitadder.gif" width="32" height="32">
<em>Contador de Bits</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.6.0</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/bitadder.png" width="44" height="42"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> O componente determinará quantos bits em 1 estão em sua(s) entrada(s) e emitirá o
número total de bits em 1 em sua saída. Por exemplo, para a entrada de 8 bits 10011101,
a saída será a 5, uma vez que há cinco bits 1 na entrada (o primeiro, o último,
e uma sequência de três bits no meio).
</p>
<p> Se qualquer um dos bits de entrada for um valor flutuante ou erro, então a saída
conterá bits de erro na saída correspondente à faixa de saídas possíveis
dependendo se os valores de erro/flutuante forem contados como zeros ou uns.
Por exemplo, se a entrada de 14 bits for 111x10110x1101, a saída deve ser
pelo menos 9 (se cada "x" for interpretado como zero)
e no máximo 11 (se eles forem interpretados como um).
Assim, a saída será 10EE: os dois bits mais significativos serão 1 e 0, pois todos
os inteiros entre 9 e 11 têm 1 e 0 como seus dois primeiros bits, mas os dois últimos
bits serão EE já que os inteiros entre 9 e 11 variam dentro desses limites.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste (entradas, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> As entradas cujos bits em 1 serão contados. O número de entradas será baseado
no atributo Número de Entradas. </dd>
<dt> Na face leste (saída, com largura en bits calculada conforme descrito abaixo) </dt>
<dd> O número de bits de entrada iguais a 1. A largura em bits na saída será o
número mínimo de bits para armazenar o maior valor possível (que seria
o produto do atributo Bits de Dados pelo atributo Número de Entradas). </dd>
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
os dígito de '0' a '9' poderão alterar seu atributo <q>Número de Entradas</q> e
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
<dl>
<dt> Bits de dados </dt>
<dd> Largura em bits da(s) entrada(s).</dd>
<dt> Número de Entradas </dt>
<dd> Número de valores de entrada.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

224
doc/pt/html/libs/arith/bitfinder.html
View File

@ -1,112 +1,112 @@
<html>
<head>
<title>Indexador de Bits</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/bitfindr.gif" width="32" height="32">
<em>Indexador de Bits</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Arithmetic</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.6.1</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/bitfindr.png" width="44" height="43"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> O componente receberá uma entrada multibit e determinará o índice de um bit,
onde esse índice será calculado pela contagem iniciando em 0 no bit de mais baixa ordem.
O índice exato a ser calculado dependerá do atributo Tipo, como ilustrado
nos exemplos do quadro abaixo para a amostra de 8 bits de uma entrada igual a
11010100. </p>
<blockquote><table><thead>
<tr><th>Tipo</th><th>Saída para 11010100</th></td></tr>
</thead><tbody>
<tr><td>Bit menos significativo em 1</td><td align="center">2</td></tr>
<tr><td>Bit mais significativo em 1</td><td align="center">7</td></tr>
<tr><td>Bit menos significativo em 0</td><td align="center">0</td></tr>
<tr><td>Bit mais significativo 0</td><td align="center">5</td></tr>
</tbody></table></blockquote>
<p> Para o 1 de mais baixa ordem, a saída será 2 porque começando o índice de bits
em 0 para o bit de mais baixa ordem, o primeiro 1, a ser encontrado será no índice 2.
(Os bits de índices iguais a 0 e 1 são iguais a 0).
Para o 1 de mais alta ordem, a saída será 7 porque o bit 1 mais significativo
corresponderá ao índice 7 (mais uma vez contando a partir do bit de mais baixa ordem
começando em 0).
</p>
<p> A saída do componente na face sul indicará se o bit desejado
foi encontrado. Nos exemplos acima, envolvendo a entrada 11010100,
a saída sul será igual a 1 em todos os casos.
Mas se a entrada fosse 00000000 e o componente não encontrasse o 1 de
mais baixa ordem, então a saída ao sul seria 0 - e a saída borda a oeste
seria 0 também.
</p>
<p> Se durante a pesquisa pelo valor desejado, um valor diferente de 0 ou 1 for
encontrado (o bit pode ser flutuante ou um valor de erro),
então, as duas saídas serão compostas inteiramente por bits de erro.
Observar que isso ocorrerá apenas se o bit com problema for encontrado antes do bit
desejado. Para a entrada x1010100, por exemplo, a saída ainda seria 2, se
o valor 1 de mais baixa ordem for o desejado; contudo, obteremos valores de erro
se o componente estiver a procurar o valor 0 ou 1 de mais alta ordem, uma vez que
haverá um bit errado na posição mais significativa independente de ser 0 ou 1
o bit de mais alta ordem.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> A entrada multibit onde será procurado o bit desejado. </dd>
<dt> Na face leste (saída, com largura em bits calculada conforme descrito abaixo) </dt>
<dd> O índice do bit desejado, a contar de 0 para o bit de mais baixa ordem.
A largura mínima em bits será a necessária para armazenar o máximo valor possível para índice,
que deverá ser inferior ao valor do atributo Bits de Dados. </dd>
<dt> Na face sul (saída, largura de 1 bit) </dt>
<dd> Será 1, se o bit desejado for encontrado; 0, se todos os bits à entrada forem o
inverso do bit desejado; e será igual ao valor de erro, se um valor diferente de 0 e
de 1 for encontrado antes do bit desejado. </dd>
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados </dt>
<dd> A largura em bits da entrada. </dd>
<dt> Tipo </dt>
<dd> Serve para indicar qual o bit a ser procurado por &mdash; o 0 de mais baixa ordem,
o 0 de mais alta ordem, o 1 de mais baixa ordem, e o 1 de mais alta ordem.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Indexador de Bits</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/bitfindr.gif" width="32" height="32">
<em>Indexador de Bits</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Arithmetic</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.6.1</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/bitfindr.png" width="44" height="43"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> O componente receberá uma entrada multibit e determinará o índice de um bit,
onde esse índice será calculado pela contagem iniciando em 0 no bit de mais baixa ordem.
O índice exato a ser calculado dependerá do atributo Tipo, como ilustrado
nos exemplos do quadro abaixo para a amostra de 8 bits de uma entrada igual a
11010100. </p>
<blockquote><table><thead>
<tr><th>Tipo</th><th>Saída para 11010100</th></td></tr>
</thead><tbody>
<tr><td>Bit menos significativo em 1</td><td align="center">2</td></tr>
<tr><td>Bit mais significativo em 1</td><td align="center">7</td></tr>
<tr><td>Bit menos significativo em 0</td><td align="center">0</td></tr>
<tr><td>Bit mais significativo 0</td><td align="center">5</td></tr>
</tbody></table></blockquote>
<p> Para o 1 de mais baixa ordem, a saída será 2 porque começando o índice de bits
em 0 para o bit de mais baixa ordem, o primeiro 1, a ser encontrado será no índice 2.
(Os bits de índices iguais a 0 e 1 são iguais a 0).
Para o 1 de mais alta ordem, a saída será 7 porque o bit 1 mais significativo
corresponderá ao índice 7 (mais uma vez contando a partir do bit de mais baixa ordem
começando em 0).
</p>
<p> A saída do componente na face sul indicará se o bit desejado
foi encontrado. Nos exemplos acima, envolvendo a entrada 11010100,
a saída sul será igual a 1 em todos os casos.
Mas se a entrada fosse 00000000 e o componente não encontrasse o 1 de
mais baixa ordem, então a saída ao sul seria 0 - e a saída borda a oeste
seria 0 também.
</p>
<p> Se durante a pesquisa pelo valor desejado, um valor diferente de 0 ou 1 for
encontrado (o bit pode ser flutuante ou um valor de erro),
então, as duas saídas serão compostas inteiramente por bits de erro.
Observar que isso ocorrerá apenas se o bit com problema for encontrado antes do bit
desejado. Para a entrada x1010100, por exemplo, a saída ainda seria 2, se
o valor 1 de mais baixa ordem for o desejado; contudo, obteremos valores de erro
se o componente estiver a procurar o valor 0 ou 1 de mais alta ordem, uma vez que
haverá um bit errado na posição mais significativa independente de ser 0 ou 1
o bit de mais alta ordem.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> A entrada multibit onde será procurado o bit desejado. </dd>
<dt> Na face leste (saída, com largura em bits calculada conforme descrito abaixo) </dt>
<dd> O índice do bit desejado, a contar de 0 para o bit de mais baixa ordem.
A largura mínima em bits será a necessária para armazenar o máximo valor possível para índice,
que deverá ser inferior ao valor do atributo Bits de Dados. </dd>
<dt> Na face sul (saída, largura de 1 bit) </dt>
<dd> Será 1, se o bit desejado for encontrado; 0, se todos os bits à entrada forem o
inverso do bit desejado; e será igual ao valor de erro, se um valor diferente de 0 e
de 1 for encontrado antes do bit desejado. </dd>
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados </dt>
<dd> A largura em bits da entrada. </dd>
<dt> Tipo </dt>
<dd> Serve para indicar qual o bit a ser procurado por &mdash; o 0 de mais baixa ordem,
o 0 de mais alta ordem, o 1 de mais baixa ordem, e o 1 de mais alta ordem.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

162
doc/pt/html/libs/arith/comparator.html
View File

@ -1,81 +1,81 @@
<html>
<head>
<title>Comparador</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/comparator.gif" width="32" height="32">
<em>Comparador</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 22</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/comparator.png" width="44" height="43"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Serve para comparar dois valores, quer sejam sem sinal ou em complemento de dois,
dependendo do atributo Tipo Numérico. Normalmente, uma das saídas será 1, e as outras
duas saídas serão 0. </p>
<p> A comparação será feita a partir dos bits mais significativos em
cada número e irá decrescendo, em paralelo, até onde forem encontrados dois valores
em desacordo. Se, no entanto, um erro ou valor flutuante for encontrado, então,
todas as saídas irão corresponder a esse erro ou ao valor flutuante. </p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, extremo norte (entrada, com largura em bits de acordo com o
atributo Bits de Dados)
<dd> O primeiro dos dois valores a serem comparados.
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados)
<dd> O segundo dos dois valores a serem comparados.
<dt> Na face leste, marcado por <tt>>&gt;</tt> (saída, com largura de 1 bit)
<dd> Será 1, se a primeira entrada for maior que a segunda; ou 0,
se a primeira entrada for menor ou igual à segunda.
<dt> Na face leste, marcado por <tt>=</tt> (saída, com largura de 1 bit)
<dd> Será 1, se a primeira entrada é igual à segunda; ou 0,
se a primeira entrada não for igual à segunda.
<dt> Na face leste, marcado por <tt>&lt;</tt> (saída, com largura de 1 bit)
<dd> Será 1, se a primeira entrada for menor que a segunda; ou 0,
se a primeira entrada for maior ou igual a segunda.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de dados</dt>
<dd> Largura dos bits de dados da entrada e da saída do componente.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Comparador</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/comparator.gif" width="32" height="32">
<em>Comparador</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 22</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/comparator.png" width="44" height="43"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Serve para comparar dois valores, quer sejam sem sinal ou em complemento de dois,
dependendo do atributo Tipo Numérico. Normalmente, uma das saídas será 1, e as outras
duas saídas serão 0. </p>
<p> A comparação será feita a partir dos bits mais significativos em
cada número e irá decrescendo, em paralelo, até onde forem encontrados dois valores
em desacordo. Se, no entanto, um erro ou valor flutuante for encontrado, então,
todas as saídas irão corresponder a esse erro ou ao valor flutuante. </p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, extremo norte (entrada, com largura em bits de acordo com o
atributo Bits de Dados)
<dd> O primeiro dos dois valores a serem comparados.
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados)
<dd> O segundo dos dois valores a serem comparados.
<dt> Na face leste, marcado por <tt>>&gt;</tt> (saída, com largura de 1 bit)
<dd> Será 1, se a primeira entrada for maior que a segunda; ou 0,
se a primeira entrada for menor ou igual à segunda.
<dt> Na face leste, marcado por <tt>=</tt> (saída, com largura de 1 bit)
<dd> Será 1, se a primeira entrada é igual à segunda; ou 0,
se a primeira entrada não for igual à segunda.
<dt> Na face leste, marcado por <tt>&lt;</tt> (saída, com largura de 1 bit)
<dd> Será 1, se a primeira entrada for menor que a segunda; ou 0,
se a primeira entrada for maior ou igual a segunda.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de dados</dt>
<dd> Largura dos bits de dados da entrada e da saída do componente.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

210
doc/pt/html/libs/arith/divider.html
View File

@ -1,105 +1,105 @@
<html>
<head>
<title>Divisor</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/divider.gif" width="32" height="32">
<em>Divisor</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 22</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/divider.png" width="44" height="45"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Esse componente divide dois valores que vierem através das entradas a oeste e
fornecerá o quociente na saída a leste. O componente é projetado de forma
a poder ser conectado a outros divisores tratar um dividendo com mais bits que
o possível apenas um único divisor. A entrada superior fornecerá com os bits mais
significativos dentre os <var> Bits de Dados</var> do dividendo
(se isso tiver sido especificado), e os bits em <var>rem</var> serão o resto inteiro
da divisão, que pode ser enviado para a entrada <var>superior</var> em outro divisor.
</p>
<p> Se o divisor for 0, nenhuma divisão será feita (ou seja, supõe-se o divisor
no mínimo igual a 1).
</p>
<p> O divisor executará essencialmente uma divisão sem sinal. Ou seja, o
resto estará sempre entre 0 e <var> divisor </var>-1. O quociente será sempre um
número inteiro de modo que
</p>
<center>
<var>quociente </var> * <var> divisor </var> + <var>resto</var> = <var> dividendo </var>.
</center>
<p> Se, no entanto, o <var>quociente</var> não couber nos <var> Bits de Dados </var>,
apenas os bits menos significativos serão reportados. O componente não oferecerá método
algum para o acesso aos bits mais significativos dos <var> Bits de Dados </var>.
</p>
<p> Se qualquer um dos operandos contiver algum bit flutuante, ou com erro,
então o componente terá as saídas ou inteiramente flutuantes ou
integralmente com valores de erro.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, extremo norte (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits menos significativos dentre os <var> Bits de Dados </var> do dividendo
(ou seja, o primeiro operando para a divisão).
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O divisor (ou seja, o segundo operando para a divisão).
<dt> Na face norte, marcado por <var>upper</var> (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits mais significativos dentre os <var> Bits de Dados </var> do dividendo
(ou seja, o primeiro operando para a divisão).
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits menos significativos dentre os <var> Bits de Dados </var> do quociente,
conforme especificado acima.
<dt> Na face sul, marcado por <var>rem</var> (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O resto da divisão. Esse valor estará sempre entre 0 e <var>divisor</var>-1.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados </dt>
<dd> A largura em bits dos valores a serem divididos e o resultado.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Divisor</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/divider.gif" width="32" height="32">
<em>Divisor</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 22</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/divider.png" width="44" height="45"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Esse componente divide dois valores que vierem através das entradas a oeste e
fornecerá o quociente na saída a leste. O componente é projetado de forma
a poder ser conectado a outros divisores tratar um dividendo com mais bits que
o possível apenas um único divisor. A entrada superior fornecerá com os bits mais
significativos dentre os <var> Bits de Dados</var> do dividendo
(se isso tiver sido especificado), e os bits em <var>rem</var> serão o resto inteiro
da divisão, que pode ser enviado para a entrada <var>superior</var> em outro divisor.
</p>
<p> Se o divisor for 0, nenhuma divisão será feita (ou seja, supõe-se o divisor
no mínimo igual a 1).
</p>
<p> O divisor executará essencialmente uma divisão sem sinal. Ou seja, o
resto estará sempre entre 0 e <var> divisor </var>-1. O quociente será sempre um
número inteiro de modo que
</p>
<center>
<var>quociente </var> * <var> divisor </var> + <var>resto</var> = <var> dividendo </var>.
</center>
<p> Se, no entanto, o <var>quociente</var> não couber nos <var> Bits de Dados </var>,
apenas os bits menos significativos serão reportados. O componente não oferecerá método
algum para o acesso aos bits mais significativos dos <var> Bits de Dados </var>.
</p>
<p> Se qualquer um dos operandos contiver algum bit flutuante, ou com erro,
então o componente terá as saídas ou inteiramente flutuantes ou
integralmente com valores de erro.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, extremo norte (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits menos significativos dentre os <var> Bits de Dados </var> do dividendo
(ou seja, o primeiro operando para a divisão).
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O divisor (ou seja, o segundo operando para a divisão).
<dt> Na face norte, marcado por <var>upper</var> (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits mais significativos dentre os <var> Bits de Dados </var> do dividendo
(ou seja, o primeiro operando para a divisão).
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits menos significativos dentre os <var> Bits de Dados </var> do quociente,
conforme especificado acima.
<dt> Na face sul, marcado por <var>rem</var> (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O resto da divisão. Esse valor estará sempre entre 0 e <var>divisor</var>-1.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados </dt>
<dd> A largura em bits dos valores a serem divididos e o resultado.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

78
doc/pt/html/libs/arith/index.html
View File

@ -1,39 +1,39 @@
<html>
<head>
<title>Biblioteca aritmética</title>
</head>
<body bgcolor="FFFFFF">
<h1>Biblioteca aritmética</h1>
<p> A biblioteca inclui componentes combinacionais capazes de
executar operações aritméticas com valores inteiros sem sinal e
também com valores em complemento de dois.
</p>
<table>
<tr><td align="right"><a href="adder.html"><img border="0" src="../../icons/adder.gif" width="16" height="16"></a></td>
<td><a href="adder.html">Somador</a></td></tr>
<tr><td align="right"><a href="subtractor.html"><img border="0" src="../../icons/subtractor.gif" width="16" height="16"></a></td>
<td><a href="subtractor.html">Subtrator</a></td></tr>
<tr><td align="right"><a href="multiplier.html"><img border="0" src="../../icons/multiplier.gif" width="16" height="16"></a></td>
<td><a href="multiplier.html">Multiplicador</a></td></tr>
<tr><td align="right"><a href="divider.html"><img border="0" src="../../icons/divider.gif" width="16" height="16"></a></td>
<td><a href="divider.html">Divisor</a></td></tr>
<tr><td align="right"><a href="negator.html"><img border="0" src="../../icons/negator.gif" width="16" height="16"></a></td>
<td><a href="negator.html">Negador</a></td></tr>
<tr><td align="right"><a href="comparator.html"><img border="0" src="../../icons/comparator.gif" width="16" height="16"></a></td>
<td><a href="comparator.html">Comparador</a></td></tr>
<tr><td align="right"><a href="shifter.html"><img border="0" src="../../icons/shifter.gif" width="16" height="16"></a></td>
<td><a href="shifter.html">Deslocador</a></td></tr>
<tr><td align="right"><a href="bitadder.html"><img border="0" src="../../icons/bitadder.gif" width="16" height="16"></a></td>
<td><a href="bitadder.html">Contador de Bits</a></td></tr>
<tr><td align="right"><a href="bitfinder.html"><img border="0" src="../../icons/bitfindr.gif" width="16" height="16"></a></td>
<td><a href="bitfinder.html">Indexador de Bits</a></td></tr>
</table>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Biblioteca aritmética</title>
</head>
<body bgcolor="FFFFFF">
<h1>Biblioteca aritmética</h1>
<p> A biblioteca inclui componentes combinacionais capazes de
executar operações aritméticas com valores inteiros sem sinal e
também com valores em complemento de dois.
</p>
<table>
<tr><td align="right"><a href="adder.html"><img border="0" src="../../icons/adder.gif" width="16" height="16"></a></td>
<td><a href="adder.html">Somador</a></td></tr>
<tr><td align="right"><a href="subtractor.html"><img border="0" src="../../icons/subtractor.gif" width="16" height="16"></a></td>
<td><a href="subtractor.html">Subtrator</a></td></tr>
<tr><td align="right"><a href="multiplier.html"><img border="0" src="../../icons/multiplier.gif" width="16" height="16"></a></td>
<td><a href="multiplier.html">Multiplicador</a></td></tr>
<tr><td align="right"><a href="divider.html"><img border="0" src="../../icons/divider.gif" width="16" height="16"></a></td>
<td><a href="divider.html">Divisor</a></td></tr>
<tr><td align="right"><a href="negator.html"><img border="0" src="../../icons/negator.gif" width="16" height="16"></a></td>
<td><a href="negator.html">Negador</a></td></tr>
<tr><td align="right"><a href="comparator.html"><img border="0" src="../../icons/comparator.gif" width="16" height="16"></a></td>
<td><a href="comparator.html">Comparador</a></td></tr>
<tr><td align="right"><a href="shifter.html"><img border="0" src="../../icons/shifter.gif" width="16" height="16"></a></td>
<td><a href="shifter.html">Deslocador</a></td></tr>
<tr><td align="right"><a href="bitadder.html"><img border="0" src="../../icons/bitadder.gif" width="16" height="16"></a></td>
<td><a href="bitadder.html">Contador de Bits</a></td></tr>
<tr><td align="right"><a href="bitfinder.html"><img border="0" src="../../icons/bitfindr.gif" width="16" height="16"></a></td>
<td><a href="bitfinder.html">Indexador de Bits</a></td></tr>
</table>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

184
doc/pt/html/libs/arith/multiplier.html
View File

@ -1,92 +1,92 @@
<html>
<head>
<title>Multiplicador</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/multiplier.gif" width="32" height="32">
<em>Multiplicador</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 20</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/multiplier.png" width="44" height="45"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Esse componente multiplicará os dois valores que vierem através das entradas a oeste
e fornecerá o produto na saída leste. O componente é projetado de forma
a poder ser conectado a outros multiplicadores para tratar com um
multiplicando com mais bits do que for possível para um único multiplicador.
A entrada <i>carry-in</i> fornecerá um valor multibit para ser adicionado ao
produto (se ele for especificado), e saída <i>carry-out</i> fornecerá a metade superior
do resultado do produto, que poderá ser enviada para outro multiplicador. </p>
<p> Se o multiplicando, o multiplicador, ou a entrada <i>carry-in</i> de entrada contiverem
algum bit flutuante ou erro, então, o componente irá realizar uma
multiplicação parcial. Ou seja, ele irá calcular como tantos bits de mais baixa ordem
quanto possível. Mas acima do bit flutuante ou do erro, o resultado terá
bits flutuantes ou de erro. Observar que se a entrada <i>carry-in</i> for completamente
flutuante, então serão supostos todos os valores iguais a zero.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, extremo norte (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O multiplicando (ou seja, o primeiro dos dois números para se
multiplicar).
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O multiplicador (ou seja, o segundo dos dois números a serem multiplicados).
<dt> Na face norte, marcado por <var>c in</var> (entrada, com largura em bits
de acordo com o atributo Bits de Dados) </dt>
<dd> Valor de <i>carry-in</i> a ser adicionado ao produto. Se todos os bits do valor forem
desconhecidos (ou seja, flutuantes), então eles serão considerados iguais a 0.
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits de mais baixa ordem dos <var>Bits de Dados </var> do produto dos
dois valores que vierem da face oeste, mais o valor do
<var>c </var><sub><var>in</var></sub>.
<dt> Na face sul, marcado <var>c out</var> (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits mais significativos dos <var> Bits de Dados </var> do produto.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados</dt>
<dd> A largura dos bits dos valores a serem multiplicados e também do resultado.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Multiplicador</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/multiplier.gif" width="32" height="32">
<em>Multiplicador</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 20</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/multiplier.png" width="44" height="45"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Esse componente multiplicará os dois valores que vierem através das entradas a oeste
e fornecerá o produto na saída leste. O componente é projetado de forma
a poder ser conectado a outros multiplicadores para tratar com um
multiplicando com mais bits do que for possível para um único multiplicador.
A entrada <i>carry-in</i> fornecerá um valor multibit para ser adicionado ao
produto (se ele for especificado), e saída <i>carry-out</i> fornecerá a metade superior
do resultado do produto, que poderá ser enviada para outro multiplicador. </p>
<p> Se o multiplicando, o multiplicador, ou a entrada <i>carry-in</i> de entrada contiverem
algum bit flutuante ou erro, então, o componente irá realizar uma
multiplicação parcial. Ou seja, ele irá calcular como tantos bits de mais baixa ordem
quanto possível. Mas acima do bit flutuante ou do erro, o resultado terá
bits flutuantes ou de erro. Observar que se a entrada <i>carry-in</i> for completamente
flutuante, então serão supostos todos os valores iguais a zero.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, extremo norte (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O multiplicando (ou seja, o primeiro dos dois números para se
multiplicar).
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O multiplicador (ou seja, o segundo dos dois números a serem multiplicados).
<dt> Na face norte, marcado por <var>c in</var> (entrada, com largura em bits
de acordo com o atributo Bits de Dados) </dt>
<dd> Valor de <i>carry-in</i> a ser adicionado ao produto. Se todos os bits do valor forem
desconhecidos (ou seja, flutuantes), então eles serão considerados iguais a 0.
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits de mais baixa ordem dos <var>Bits de Dados </var> do produto dos
dois valores que vierem da face oeste, mais o valor do
<var>c </var><sub><var>in</var></sub>.
<dt> Na face sul, marcado <var>c out</var> (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits mais significativos dos <var> Bits de Dados </var> do produto.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados</dt>
<dd> A largura dos bits dos valores a serem multiplicados e também do resultado.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

134
doc/pt/html/libs/arith/negator.html
View File

@ -1,67 +1,67 @@
<html>
<head>
<title>Negador</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/negator.gif" width="32" height="32">
<em>Negador</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 22</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/negator.png" width="44" height="43"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Serve para calcular o complemento de dois da entrada. Essa operação será
realizada através da manutenção de todos os bits de ordem inferior até o
primeiro 1 de mais baixa ordem, e completando todos os bits acima disso. </p>
<p> Se o valor à entrada já for o menor valor negativo, então a operação
não se realizará (pois não poderá ser representada na forma de complemento de dois),
e permanecerá como o menor valor negativo. </p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste (entrada, com largura em bits de acordo com o atributo Bits de Dados)
<dd> O valor para se negar.
<dt> Na face leste, marcado por -<var>x</var> (saída, com largura de bits de acordo com o atributo Bits de Dados)
<dd> A negação da entrada. Se a entrada ultrapassar o menor valor negativo representável
no atributo <var>Bits de Dados</var>, então, a saída coincidirá com a entrada.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de dados</dt>
<dd> Largura dos bits de dados da entrada e da saída do componente.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Negador</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/negator.gif" width="32" height="32">
<em>Negador</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 22</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/negator.png" width="44" height="43"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Serve para calcular o complemento de dois da entrada. Essa operação será
realizada através da manutenção de todos os bits de ordem inferior até o
primeiro 1 de mais baixa ordem, e completando todos os bits acima disso. </p>
<p> Se o valor à entrada já for o menor valor negativo, então a operação
não se realizará (pois não poderá ser representada na forma de complemento de dois),
e permanecerá como o menor valor negativo. </p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste (entrada, com largura em bits de acordo com o atributo Bits de Dados)
<dd> O valor para se negar.
<dt> Na face leste, marcado por -<var>x</var> (saída, com largura de bits de acordo com o atributo Bits de Dados)
<dd> A negação da entrada. Se a entrada ultrapassar o menor valor negativo representável
no atributo <var>Bits de Dados</var>, então, a saída coincidirá com a entrada.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de dados</dt>
<dd> Largura dos bits de dados da entrada e da saída do componente.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

236
doc/pt/html/libs/arith/shifter.html
View File

@ -1,118 +1,118 @@
<html>
<head>
<title>Deslocador</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/shifter.gif" width="32" height="32">
<em>Deslocador</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.3.0</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/shifter.png" width="44" height="42"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Esse componente inclui duas entradas, os <var>dados</var> e <var>dist</var>, e
uma saída, que será o resultado do deslocamento dos <var>dados</var> por
<var>dist</var> posições. Ambos, os <var>dados</var> e a saída, possuem o mesmo
número de bits. O componente oferece os seguintes tipos de deslocamento:
</p>
<ul>
<li> Lógico para a Esquerda: Todos os bits de <var>dados</var> serão deslocados
no sentido dos bits mais significativo <var>dist</var> posições, com os bits
menos significativos nas <var>dist</var> posições sendo preenchidos com 0's.
Por exemplo, 11001011 logicamente deslocado para a esquerda duas vezes será 00101100.
(Os dois primeiros serão perdidos.) </li>
<li> Lógico para a Direita: Todos os bits de <var>dados</var> serão deslocados
no sentido dos bits menos significativos <var>dist</var> posições, com os
bits mais significativos nas <var>dist</var> posições preenchidos com 0's.
Por exemplo, 11001011 logicamente deslocado para a direita duas vezes será 00110010.
(Os dois últimos serão perdidos.) </li>
<li> Aritmético para a direita: Todos os bits de <var>dados</var> serão deslocados
no sentido dos bits menos significativos <var>dist</var> posições, com a parte
mais significativa das <var>dist</var> posições preenchidas com qualquer que seja
o conteúdo igualmente na parte mais significativa dos <var>dados</var>.
Por exemplo, 11001011 aritmeticamente deslocado para a direita duas vezes será 11110010.
</li>
<li> Com Rotação para a Esquerda: Todos os bits de <var>dados</var> serão deslocados
no sentido dos bits mais significativo <var>dist</var> posições, com os bits mais
significativos das <var>dist</var> posições copiados para a parte menos significativa.
Por exemplo, 11001011 rotacionado para a esquerda duas vezes será 00101111. </li>
<li> Com Rotação para a Direita: Todos os bits de <var>dados</var> serão deslocados
no sentido dos bits menos significativo <var>dist</var> posições, com os bits menos
significativos das <var>dist</var> posições copiados para a parte mais significativa.
Por exemplo, 11001011 direito rotacionado duas vezes será 11110010. </li>
</ul>
<p> Observar que <var>dist</var> contiver quaisquer entradas flutuantes ou erro,
a saída será composta inteiramente por valores de erro, já que não há maneira de
supor até que ponto deverá ser deslocada a entrada.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, extremo norte (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O valor a ser deslocado. </dd>
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O número de bits para os quais a entrada de <var>dados</var> deverá ser deslocada.
Essa entrada deverá ter tantos bits quanto o número mínimo para indicar qualquer
distância desde 0 até Bits de Dados menos um, ou seja, deverá ter como limite máximo
o logaritmo de base 2 dos Bits de Dados. Por exemplo, se os bits de dados
forem 8, essa entrada exigirá 3 bits; mas, se fosse 9, exigiria 4 bits. </dd>
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O resultado do deslocamento do valor de entrada pela quantidade em posições. </dd>
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados </dt>
<dd> A largura em bits dos <var>dados</var> de entrada e de saída.</dd>
<dt> Tipo de deslocamento </dt>
<dd> Um dos cinco tipos possíveis para deslocamento como destacado acima
(Lógico para a Esquerda, Lógico para a Direita, Aritmético para a Direita,
Com Rotação para a Esquerda, Com Rotação para a Direita).
</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Deslocador</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/shifter.gif" width="32" height="32">
<em>Deslocador</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.3.0</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/shifter.png" width="44" height="42"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Esse componente inclui duas entradas, os <var>dados</var> e <var>dist</var>, e
uma saída, que será o resultado do deslocamento dos <var>dados</var> por
<var>dist</var> posições. Ambos, os <var>dados</var> e a saída, possuem o mesmo
número de bits. O componente oferece os seguintes tipos de deslocamento:
</p>
<ul>
<li> Lógico para a Esquerda: Todos os bits de <var>dados</var> serão deslocados
no sentido dos bits mais significativo <var>dist</var> posições, com os bits
menos significativos nas <var>dist</var> posições sendo preenchidos com 0's.
Por exemplo, 11001011 logicamente deslocado para a esquerda duas vezes será 00101100.
(Os dois primeiros serão perdidos.) </li>
<li> Lógico para a Direita: Todos os bits de <var>dados</var> serão deslocados
no sentido dos bits menos significativos <var>dist</var> posições, com os
bits mais significativos nas <var>dist</var> posições preenchidos com 0's.
Por exemplo, 11001011 logicamente deslocado para a direita duas vezes será 00110010.
(Os dois últimos serão perdidos.) </li>
<li> Aritmético para a direita: Todos os bits de <var>dados</var> serão deslocados
no sentido dos bits menos significativos <var>dist</var> posições, com a parte
mais significativa das <var>dist</var> posições preenchidas com qualquer que seja
o conteúdo igualmente na parte mais significativa dos <var>dados</var>.
Por exemplo, 11001011 aritmeticamente deslocado para a direita duas vezes será 11110010.
</li>
<li> Com Rotação para a Esquerda: Todos os bits de <var>dados</var> serão deslocados
no sentido dos bits mais significativo <var>dist</var> posições, com os bits mais
significativos das <var>dist</var> posições copiados para a parte menos significativa.
Por exemplo, 11001011 rotacionado para a esquerda duas vezes será 00101111. </li>
<li> Com Rotação para a Direita: Todos os bits de <var>dados</var> serão deslocados
no sentido dos bits menos significativo <var>dist</var> posições, com os bits menos
significativos das <var>dist</var> posições copiados para a parte mais significativa.
Por exemplo, 11001011 direito rotacionado duas vezes será 11110010. </li>
</ul>
<p> Observar que <var>dist</var> contiver quaisquer entradas flutuantes ou erro,
a saída será composta inteiramente por valores de erro, já que não há maneira de
supor até que ponto deverá ser deslocada a entrada.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, extremo norte (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O valor a ser deslocado. </dd>
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O número de bits para os quais a entrada de <var>dados</var> deverá ser deslocada.
Essa entrada deverá ter tantos bits quanto o número mínimo para indicar qualquer
distância desde 0 até Bits de Dados menos um, ou seja, deverá ter como limite máximo
o logaritmo de base 2 dos Bits de Dados. Por exemplo, se os bits de dados
forem 8, essa entrada exigirá 3 bits; mas, se fosse 9, exigiria 4 bits. </dd>
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O resultado do deslocamento do valor de entrada pela quantidade em posições. </dd>
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados </dt>
<dd> A largura em bits dos <var>dados</var> de entrada e de saída.</dd>
<dt> Tipo de deslocamento </dt>
<dd> Um dos cinco tipos possíveis para deslocamento como destacado acima
(Lógico para a Esquerda, Lógico para a Direita, Aritmético para a Direita,
Com Rotação para a Esquerda, Com Rotação para a Direita).
</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

192
doc/pt/html/libs/arith/subtractor.html
View File

@ -1,96 +1,96 @@
<html>
<head>
<title>Subtrator</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/subtractor.gif" width="32" height="32">
<em>Subtrator</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 11</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/subtractor.png" width="44" height="45"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Esse componente subtrairá os valores que vierem através das entradas a oeste
(o superior menos o inferior) e fornecerá na saída leste a diferença. O componente
é projetado de modo a poder ser conectado a outros subtratores para subtrair mais
bits do que for possível com um único subtractor. A entrada <i>borrow-in</i> fornecerá um
valor de um bit que deverá ser tomado emprestado fora da diferença (se o empréstimo
tivier sido especificado), e um <i>borrow-out</i> indicará se o componente precisar pedir
um bit de mais alta ordem para completar a subtração sem <i>underflow</i> (supondo
subtração sem sinal).
</p>
<p> Internamente, o subtrator simplesmente executará uma negação (NOT) bit a bit no
subtraendo, e irá adicioná-lo ao minuendo, juntamente com a negação da entrada
relativa ao <i>borrow-in</i>. (O <em>minuendo</em> é o primeiro operando (entrada superior),
e o <em>subtraendo</em> será o segundo (entrada inferior). Acontece que gosto dos termos antiquados.)
</p>
<p> Se um dos operandos contiver algum bit flutuante, ou de erro, então o componente
irá executar uma subtração parcial. Ou seja, irá calcular usando os bits de mais baixa
ordem possíveis. Porém, acima do bit flutuante, ou de erro, o resultado terá bits
flutuante ou de erro.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, extremo norte (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O minuendo da subtração, ou seja, o número a partir do qual se irá subtrair.
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O subtraendo da subtração, ou seja, o número que será subtraído do minuendo.
<dt> Na face norte, marcado <var>b in</var> (entrada, com largura de 1 bit) </dt>
<dd> Se for 1, então 1 será emprestado fora da diferença. Se o valor for
desconhecido (ou seja, flutuante), então será tomado como sendo igual a 0.
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits menos significativos dos <var> Bits de Dados </var> da diferença dentre
os dois valores oriundos da face oeste, menos o <var>b</var><sub><var>in</var></sub>.
<dt> Na face sul, marcado <var>b out</var> (saída, com largura de 1 bit) </dt>
<dd> O bit de empréstimo calculado para a diferença. Se os valores subtraídos
como valores sem sinal produzirem um valor negativo, então esse bit será 1;
caso contrário, será 0.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados </dt>
<dd> A largura em bits dos valores a serem subtraídos e do resultado.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Subtrator</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/subtractor.gif" width="32" height="32">
<em>Subtrator</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Aritmética</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 11</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/subtractor.png" width="44" height="45"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Esse componente subtrairá os valores que vierem através das entradas a oeste
(o superior menos o inferior) e fornecerá na saída leste a diferença. O componente
é projetado de modo a poder ser conectado a outros subtratores para subtrair mais
bits do que for possível com um único subtractor. A entrada <i>borrow-in</i> fornecerá um
valor de um bit que deverá ser tomado emprestado fora da diferença (se o empréstimo
tivier sido especificado), e um <i>borrow-out</i> indicará se o componente precisar pedir
um bit de mais alta ordem para completar a subtração sem <i>underflow</i> (supondo
subtração sem sinal).
</p>
<p> Internamente, o subtrator simplesmente executará uma negação (NOT) bit a bit no
subtraendo, e irá adicioná-lo ao minuendo, juntamente com a negação da entrada
relativa ao <i>borrow-in</i>. (O <em>minuendo</em> é o primeiro operando (entrada superior),
e o <em>subtraendo</em> será o segundo (entrada inferior). Acontece que gosto dos termos antiquados.)
</p>
<p> Se um dos operandos contiver algum bit flutuante, ou de erro, então o componente
irá executar uma subtração parcial. Ou seja, irá calcular usando os bits de mais baixa
ordem possíveis. Porém, acima do bit flutuante, ou de erro, o resultado terá bits
flutuante ou de erro.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste, extremo norte (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O minuendo da subtração, ou seja, o número a partir do qual se irá subtrair.
<dt> Na face oeste, extremo sul (entrada, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> O subtraendo da subtração, ou seja, o número que será subtraído do minuendo.
<dt> Na face norte, marcado <var>b in</var> (entrada, com largura de 1 bit) </dt>
<dd> Se for 1, então 1 será emprestado fora da diferença. Se o valor for
desconhecido (ou seja, flutuante), então será tomado como sendo igual a 0.
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Os bits menos significativos dos <var> Bits de Dados </var> da diferença dentre
os dois valores oriundos da face oeste, menos o <var>b</var><sub><var>in</var></sub>.
<dt> Na face sul, marcado <var>b out</var> (saída, com largura de 1 bit) </dt>
<dd> O bit de empréstimo calculado para a diferença. Se os valores subtraídos
como valores sem sinal produzirem um valor negativo, então esse bit será 1;
caso contrário, será 0.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Bits de Dados </q>.
</p>
<dl>
<dt> Bits de Dados </dt>
<dd> A largura em bits dos valores a serem subtraídos e do resultado.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

174
doc/pt/html/libs/base/clock.html
View File

@ -1,87 +1,87 @@
<html>
<head>
<title>Clock</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/clock.gif" width="32" height="32">
<em><i>Clock</i></em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 13</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/clock.png" width="23" height="23"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> O <i>clock</i> alternará seu valor à saída periodicamente enquanto as variações
(<i>ticks</i>) forem habilitadas via
<a href="../../guide/menu/simulate.html">Menu Simulação</a>.
(As variações (<i>ticks</i>) estarão desabilitadas por padrão.)
Uma variação (<i>tick</i>") é a unidade de tempo do Logisim; a velocidade em que deve
ocorrer poderá ser selecionada pelo submenu Frequência de <i>Tick</i> no menu Simulação.
O ciclo do <i>clock</i> pode ser configurado para usar os atributos Duração em Alto e
Duração em Baixo.
</p>
<p> Observar que a simulação de <i>clocks</i> no Logisim's é pouco realista:
em circuitos reais, vários <i>clocks</i> podem derivar de outros e dificilmente
estão em sincronia. Mas em Logisim, todos eles experimentarão a mesma
taxa de variação de tempo.
</p>
<h2>Pinos</h2>
<p> O <i>clock</i> tem apenas um pino, uma saída com largura de 1 bit,
cujo valor representará o estado corrente do <i>clock</i>. A posição desse pino
será especificada pelo atributo Direção. O valor do <i>clock</i> irá alternar
conforme programado sempre que as variações (<i>ticks</i>) forem habilitadas,
e sempre que o componente for clicado pela <a href="poke.html">
ferramenta Testar</a>.
</p>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
as teclas com setas poderão alterar o seu atributo <q> Direção </q>.
<dl>
<dt> Direção </dt>
<dd> A face do componente onde o pino de saída deverá estar. </dd>
<dt> Duração em Alto </dt>
<dd> Quanto tempo em cada ciclo que a saída do <i>clock</i> deverá ficar em 1. </dd>
<dt> Duração em Baixo </dt>
<dd> Quanto tempo em cada ciclo que a saída do <i>clock</i> deverá ficar em 0. </dd>
<dt> Rótulo </dt>
<dd> O texto para o rótulo associado à porta. </dd>
<dt> Posição do Rótulo </dt>
<dd> A posição relativa do rótulo em relação ao componente. </dd>
<dt> Fonte do Rótulo </dt>
<dd> A fonte com a qual o rótulo será mostrado. </dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Ao clicar o componente <i>clock</i>, ele irá alternar o valor de sua saída corrente
de imediato. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Permite que o rótulo associado ao componente seja editado.</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Clock</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/clock.gif" width="32" height="32">
<em><i>Clock</i></em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 13</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/clock.png" width="23" height="23"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> O <i>clock</i> alternará seu valor à saída periodicamente enquanto as variações
(<i>ticks</i>) forem habilitadas via
<a href="../../guide/menu/simulate.html">Menu Simulação</a>.
(As variações (<i>ticks</i>) estarão desabilitadas por padrão.)
Uma variação (<i>tick</i>") é a unidade de tempo do Logisim; a velocidade em que deve
ocorrer poderá ser selecionada pelo submenu Frequência de <i>Tick</i> no menu Simulação.
O ciclo do <i>clock</i> pode ser configurado para usar os atributos Duração em Alto e
Duração em Baixo.
</p>
<p> Observar que a simulação de <i>clocks</i> no Logisim's é pouco realista:
em circuitos reais, vários <i>clocks</i> podem derivar de outros e dificilmente
estão em sincronia. Mas em Logisim, todos eles experimentarão a mesma
taxa de variação de tempo.
</p>
<h2>Pinos</h2>
<p> O <i>clock</i> tem apenas um pino, uma saída com largura de 1 bit,
cujo valor representará o estado corrente do <i>clock</i>. A posição desse pino
será especificada pelo atributo Direção. O valor do <i>clock</i> irá alternar
conforme programado sempre que as variações (<i>ticks</i>) forem habilitadas,
e sempre que o componente for clicado pela <a href="poke.html">
ferramenta Testar</a>.
</p>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
as teclas com setas poderão alterar o seu atributo <q> Direção </q>.
<dl>
<dt> Direção </dt>
<dd> A face do componente onde o pino de saída deverá estar. </dd>
<dt> Duração em Alto </dt>
<dd> Quanto tempo em cada ciclo que a saída do <i>clock</i> deverá ficar em 1. </dd>
<dt> Duração em Baixo </dt>
<dd> Quanto tempo em cada ciclo que a saída do <i>clock</i> deverá ficar em 0. </dd>
<dt> Rótulo </dt>
<dd> O texto para o rótulo associado à porta. </dd>
<dt> Posição do Rótulo </dt>
<dd> A posição relativa do rótulo em relação ao componente. </dd>
<dt> Fonte do Rótulo </dt>
<dd> A fonte com a qual o rótulo será mostrado. </dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Ao clicar o componente <i>clock</i>, ele irá alternar o valor de sua saída corrente
de imediato. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Permite que o rótulo associado ao componente seja editado.</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

366
doc/pt/html/libs/base/edit.html
View File

@ -1,183 +1,183 @@
<html>
<head>
<title>Ferramenta Editar</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/select.gif" width="32" height="32">
<em>Ferramenta Editar</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introduçãp:</strong></td>
<td>2.3.0</td></tr>
</table></p>
<h2>Comportamento</h2>
<p> A ferramenta Editar permitirá ao usuário rearranjar os componentes
que existirem e acrescentar conexões. Exatamente o que a ferramenta fará
dependerá de onde o usuário clicar com o mouse na área de desenho.
</p>
<ul>
<li><p> Quando o mouse estiver sobre um ponto de conexão de um componente
que já exista, ou sobre um fio, a ferramenta Editar irá mostrar um pequeno
círculo verde em torno na posição do mouse. Ao pressionar o botão ali, iniciará
a inclusão de uma nova conexão. Mas se o usuário não arrastar o mouse, longe o
bastante para iniciar a conexão, antes de soltar o botão, a ação será tratada
como um clique, e um fio será simplesmente adicionado à seleção corrente.
</p>
<p> A largura em bits de uma conexão acrescentada será inferida a partir dos
componentes aos quais estiver conectada. Se não estiver vinculada a qualquer
componente, um fio será traçado em cinza para indicar que sua largura é
desconhecida; houver concordância na largura com a do componente naquela posição,
a conexão será traçada em cor laranja para indicar conflito, e efetivamente não haverá
qualquer transmissão de sinal até que o usuário o resolva.
</p>
<p> Todas as conexões no Logisim serão ou horizontais ou verticais, nunca diagonais.
</p>
<p> As conexões não têm direção determinada; ou seja, elas transmitem valores
de um ponto a outro. De fato, um fio pode transportar valores em ambas direções
simultaneamente: no exemplo abaixo, um bit será transmitido da entrada superior
à esquerda através da conexão central, e então voltará por ela, e novamente
de modo circular, até alcançar a saída inferior à direita.
</p>
<center><img src="../../guide/bundles/splitter-2way.png" width="133" height="63"></center>
<p> Um simples arrastar do mouse poderá criar múltiplos segmentos de fios.
O processo mais preciso é um pouco mais difícil de se descrever; mas
funciona bem intuitivamente na prática: se você fizer uso da ferramenta
Conectar um segmento particular de fio será interrompido tão
logo atinja o pino de um componente que já exista, ou onde quer que
alcance outro segmento de fio de uma conexão também existente.
Além disso, se uma extremidade de qualquer conexão múltipla
alcançar o meio de outra já existente, então essa também passará a ter
múltiplos segmentos.
</p>
<p> Você poderá encurtar ou apagar uma conexão existente ao arrastar qualquer
das extremidades de um segmento e seguir o caminho inverso na direção da outra
extremidade. Durante o movimento, a mudança de tamanho será indicada por uma
linha branca sobre a parte do fio que estiver sendo removida.
</p>
<p> Para alguns componentes que tiverem marcas para indicar onde há pontos
de conexão disponíveis (tais como uma <a href="../gates/basic.html">porta OR</a>
ou um <a href="../gates/controlled.html">buffer controlado</a>), o Logisim,
de forma sutil, corrigirá tentativas em criar fios que ultrapassem
ligeiramente os pontos de conexão.
</p>
<li><p> Contudo, se o usuário pressionar a tecla Alt em um ponto no meio de um
fio, então o círculo verde desaparecerá. Um clique do mouse selecionará a conexão
e o mouse irá arrastá-la.
</p>
</li>
<li><p> Ao pressionar o botão do mouse enquanto ele estiver sobre um componente
selecionado ele irá arrastar todos os componentes na mesma seleção.
</p>
<p> Por padrão, Logisim irá calcular uma forma de acrescentar novos fios
de modo que nenhuma conexão existente seja perdida durante o movimento.
(Às vezes, ele irá eliminar ou encurtar fios existentes.)
Se você estiver realizando um movimento em que você queira que essas alterações
sejam feitas, você poderá pressionar a tecla <i>shift</i> durante a movimentação.
Se você quiser desabilitar esse comportamento por completo,
basta ir a Projeto &gt; Opções, selecionar a guia Área de Desenho,
e desmarcar a caixa <q> Manter Conexões ao Mover </q>;
nesse caso, as conexões serão calculadas somente quando a tecla <i>shift</i> for
<em>pressionada</em>.
</p>
<p> Ao arrastar uma seleção isso poderá levar a um comportamento inesperado dos fios:
se ao fazer isso, alguns fios passarem sobre outros, eles serão conectados,
e todos serão colocados na mesma seleção. Como resultado, se você arrastar a seleção
pela segunda vez, os fios que existirem previamente no local não serão deixados para
trás. Esse comportamento é necessário para manter coerência com o comportamento esperado
para as conexões de fios no Logisim. E não constituirá, normalmente, um grande problema:
o Logisim irá traçar a seleção inteira no instante em que desejar efetivá-la,
e você não deverá fazê-lo, até que você tenha certeza que esteja no local correto.
</p>
<li><p> Ao clicar com o mouse sobre um componente não selecionado (mas não sobre um
de seus pontos de conexão) todos os componentes da seleção atual serão fixados
e a seleção passará ao(s) componente(s) que contiver(em) a posição clicada.
</p></li>
<li><p> <i>Shift+click</i> do mouse sobre um componente alternará sua presença na seleção.
Se vários componentes compartilharem a mesma posição, a presença de todos será
alternada.
</p></li>
<li><p> Ao começar a arrastar o mouse em uma posição que não contenha qualquer
componente, fixará todos aqueles na seleção atual e iniciar o traçado de uma
área retangular para seleção.
Todos os componentes contidos dentro dessa área serão colocados na seleção.
</p></li>
<li><p> Ao clicar <i>shift</i> e arrastar o mouse a partir de uma posição que
não contiver qualquer componente iniciará uma seleção retangular. A presença
de todos os componentes contidos nessa área será alternada.
</p></li>
<li><p> Contudo, se a tecla <i>alt</i> for pressionada em uma posição que não contiver
qualquer componente, iniciará o acréscimo de uma nova conexão. Um pequeno círculo
verde será traçado em tal circunstância para indicar isso.
</p></li>
</ul></p>
<p> Após selecionar os itens desejados, você poderá, naturalmente,
recortar/copiar/colar/apagar todos os itens via
<a href="../../guide/menu/edit.html"> menu Editar </a>.
<p> Algumas teclas podem ter efeito sobre a ferramenta Editar.</p>
<ul>
<li><p> As teclas com setas poderão alterar o atributo Direção para todos os
componentes na seleção que tiverem tal atributo.
</p></li>
<li><p> As teclas <i>Delete</i> e <i>Backspace</i> irão apagar tudo
o que estiver selecionado no circuito.</p></li>
<li><p> As teclas <i>Insert</i> e <i>MenuKey-D</i> criarão uma cópia
dos componentes na seleção corrente.
</p></li>
</ul>
<p> O comportamento do Logisim ao duplicar uma seleção ou ao colar a
área de transferência em um circuito será um tanto peculiar: ele não irá colocar
imediatamente os componentes no circuito, em vez disso, a seleção será uma
coleção de "esboços transparentes", que será deixada no circuito assim que forem
levados para outra posição ou removidos da seleção. (Esse comportamento peculiar
é necessário porque, caso contrário, as conexões na
seleção seriam fundidas àquelas no circuito atual de uma só vez, e não permitir,
assim, que pudessem ser arrastadas de sua posição anterior junto
com o conteúdo da área de transferência até que fossem coladas onde o usuário desejasse.)
</p>
<h2>Atributos</h2>
<p> Nenhum. Ao selecionar um componente, ela irá mostrar seus atributos.
Se forem selecionados vários componentes, ela irá mostrar os atributos
compartilhados por todos, em branco ficarão os valores diferentes e
de outro modo, todos aqueles que tiverem em comum. (As conexões serão ignoradas
se não houver qualquer outro componente na seleção.) Mudanças no valor do atributo
afetarão todos os componentes selecionados.
</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Ferramenta Editar</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/select.gif" width="32" height="32">
<em>Ferramenta Editar</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introduçãp:</strong></td>
<td>2.3.0</td></tr>
</table></p>
<h2>Comportamento</h2>
<p> A ferramenta Editar permitirá ao usuário rearranjar os componentes
que existirem e acrescentar conexões. Exatamente o que a ferramenta fará
dependerá de onde o usuário clicar com o mouse na área de desenho.
</p>
<ul>
<li><p> Quando o mouse estiver sobre um ponto de conexão de um componente
que já exista, ou sobre um fio, a ferramenta Editar irá mostrar um pequeno
círculo verde em torno na posição do mouse. Ao pressionar o botão ali, iniciará
a inclusão de uma nova conexão. Mas se o usuário não arrastar o mouse, longe o
bastante para iniciar a conexão, antes de soltar o botão, a ação será tratada
como um clique, e um fio será simplesmente adicionado à seleção corrente.
</p>
<p> A largura em bits de uma conexão acrescentada será inferida a partir dos
componentes aos quais estiver conectada. Se não estiver vinculada a qualquer
componente, um fio será traçado em cinza para indicar que sua largura é
desconhecida; houver concordância na largura com a do componente naquela posição,
a conexão será traçada em cor laranja para indicar conflito, e efetivamente não haverá
qualquer transmissão de sinal até que o usuário o resolva.
</p>
<p> Todas as conexões no Logisim serão ou horizontais ou verticais, nunca diagonais.
</p>
<p> As conexões não têm direção determinada; ou seja, elas transmitem valores
de um ponto a outro. De fato, um fio pode transportar valores em ambas direções
simultaneamente: no exemplo abaixo, um bit será transmitido da entrada superior
à esquerda através da conexão central, e então voltará por ela, e novamente
de modo circular, até alcançar a saída inferior à direita.
</p>
<center><img src="../../guide/bundles/splitter-2way.png" width="133" height="63"></center>
<p> Um simples arrastar do mouse poderá criar múltiplos segmentos de fios.
O processo mais preciso é um pouco mais difícil de se descrever; mas
funciona bem intuitivamente na prática: se você fizer uso da ferramenta
Conectar um segmento particular de fio será interrompido tão
logo atinja o pino de um componente que já exista, ou onde quer que
alcance outro segmento de fio de uma conexão também existente.
Além disso, se uma extremidade de qualquer conexão múltipla
alcançar o meio de outra já existente, então essa também passará a ter
múltiplos segmentos.
</p>
<p> Você poderá encurtar ou apagar uma conexão existente ao arrastar qualquer
das extremidades de um segmento e seguir o caminho inverso na direção da outra
extremidade. Durante o movimento, a mudança de tamanho será indicada por uma
linha branca sobre a parte do fio que estiver sendo removida.
</p>
<p> Para alguns componentes que tiverem marcas para indicar onde há pontos
de conexão disponíveis (tais como uma <a href="../gates/basic.html">porta OR</a>
ou um <a href="../gates/controlled.html">buffer controlado</a>), o Logisim,
de forma sutil, corrigirá tentativas em criar fios que ultrapassem
ligeiramente os pontos de conexão.
</p>
<li><p> Contudo, se o usuário pressionar a tecla Alt em um ponto no meio de um
fio, então o círculo verde desaparecerá. Um clique do mouse selecionará a conexão
e o mouse irá arrastá-la.
</p>
</li>
<li><p> Ao pressionar o botão do mouse enquanto ele estiver sobre um componente
selecionado ele irá arrastar todos os componentes na mesma seleção.
</p>
<p> Por padrão, Logisim irá calcular uma forma de acrescentar novos fios
de modo que nenhuma conexão existente seja perdida durante o movimento.
(Às vezes, ele irá eliminar ou encurtar fios existentes.)
Se você estiver realizando um movimento em que você queira que essas alterações
sejam feitas, você poderá pressionar a tecla <i>shift</i> durante a movimentação.
Se você quiser desabilitar esse comportamento por completo,
basta ir a Projeto &gt; Opções, selecionar a guia Área de Desenho,
e desmarcar a caixa <q> Manter Conexões ao Mover </q>;
nesse caso, as conexões serão calculadas somente quando a tecla <i>shift</i> for
<em>pressionada</em>.
</p>
<p> Ao arrastar uma seleção isso poderá levar a um comportamento inesperado dos fios:
se ao fazer isso, alguns fios passarem sobre outros, eles serão conectados,
e todos serão colocados na mesma seleção. Como resultado, se você arrastar a seleção
pela segunda vez, os fios que existirem previamente no local não serão deixados para
trás. Esse comportamento é necessário para manter coerência com o comportamento esperado
para as conexões de fios no Logisim. E não constituirá, normalmente, um grande problema:
o Logisim irá traçar a seleção inteira no instante em que desejar efetivá-la,
e você não deverá fazê-lo, até que você tenha certeza que esteja no local correto.
</p>
<li><p> Ao clicar com o mouse sobre um componente não selecionado (mas não sobre um
de seus pontos de conexão) todos os componentes da seleção atual serão fixados
e a seleção passará ao(s) componente(s) que contiver(em) a posição clicada.
</p></li>
<li><p> <i>Shift+click</i> do mouse sobre um componente alternará sua presença na seleção.
Se vários componentes compartilharem a mesma posição, a presença de todos será
alternada.
</p></li>
<li><p> Ao começar a arrastar o mouse em uma posição que não contenha qualquer
componente, fixará todos aqueles na seleção atual e iniciar o traçado de uma
área retangular para seleção.
Todos os componentes contidos dentro dessa área serão colocados na seleção.
</p></li>
<li><p> Ao clicar <i>shift</i> e arrastar o mouse a partir de uma posição que
não contiver qualquer componente iniciará uma seleção retangular. A presença
de todos os componentes contidos nessa área será alternada.
</p></li>
<li><p> Contudo, se a tecla <i>alt</i> for pressionada em uma posição que não contiver
qualquer componente, iniciará o acréscimo de uma nova conexão. Um pequeno círculo
verde será traçado em tal circunstância para indicar isso.
</p></li>
</ul></p>
<p> Após selecionar os itens desejados, você poderá, naturalmente,
recortar/copiar/colar/apagar todos os itens via
<a href="../../guide/menu/edit.html"> menu Editar </a>.
<p> Algumas teclas podem ter efeito sobre a ferramenta Editar.</p>
<ul>
<li><p> As teclas com setas poderão alterar o atributo Direção para todos os
componentes na seleção que tiverem tal atributo.
</p></li>
<li><p> As teclas <i>Delete</i> e <i>Backspace</i> irão apagar tudo
o que estiver selecionado no circuito.</p></li>
<li><p> As teclas <i>Insert</i> e <i>MenuKey-D</i> criarão uma cópia
dos componentes na seleção corrente.
</p></li>
</ul>
<p> O comportamento do Logisim ao duplicar uma seleção ou ao colar a
área de transferência em um circuito será um tanto peculiar: ele não irá colocar
imediatamente os componentes no circuito, em vez disso, a seleção será uma
coleção de "esboços transparentes", que será deixada no circuito assim que forem
levados para outra posição ou removidos da seleção. (Esse comportamento peculiar
é necessário porque, caso contrário, as conexões na
seleção seriam fundidas àquelas no circuito atual de uma só vez, e não permitir,
assim, que pudessem ser arrastadas de sua posição anterior junto
com o conteúdo da área de transferência até que fossem coladas onde o usuário desejasse.)
</p>
<h2>Atributos</h2>
<p> Nenhum. Ao selecionar um componente, ela irá mostrar seus atributos.
Se forem selecionados vários componentes, ela irá mostrar os atributos
compartilhados por todos, em branco ficarão os valores diferentes e
de outro modo, todos aqueles que tiverem em comum. (As conexões serão ignoradas
se não houver qualquer outro componente na seleção.) Mudanças no valor do atributo
afetarão todos os componentes selecionados.
</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

172
doc/pt/html/libs/base/extender.html
View File

@ -1,86 +1,86 @@
<html>
<head>
<title>Extensor de Bits</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/extender.gif" width="32" height="32">
<em>Extensor de Bits</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.5.0</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/extender.png" width="44" height="42"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> O extensor de bits transformará um valor em outro de largura diferente.
Se for para transformar para uma largura menor, os bits de mais baixa ordem
serão simplesmente truncados. Se for para transformar para uma largura maior,
os bits menos significativos serão os mesmos, e você terá uma escolha para os
bits de mais alta ordem: eles poderão ser todos iguais a 0, ou todos iguais a 1,
o concordarem com a entrada do <q>bit de sinal</q> (o mais significativo), ou
ainda ter esse valor determinado por uma entrada adicional.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste (entrada, com largura em bits de acordo com o
atributo Largura da Entrada) </dt>
<dd><p> A entrada multibit cujo valor será transformado.</p></dd>
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Largura da Saída) </dt>
<dd><p> A saída calculada. </p></dd>
<dt> Na face norte (entrada, com largura de 1 bit) </dt>
<dd><p> Especificará como deverão ser os bits adicionais à saída.
Esse pino estará disponível apenas se o atributo Tipo da Extensão for
<q>Entrada.</q></p></dd>
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
os dígitos de '0 'a '9' poderão alterar o atributo <q> Largura da Entrada </q>,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Largura da Saída</q>.
</p>
<dl>
<dt> Largura da Entrada </dt>
<dd> A largura em bits da entrada. </dd>
<dt> Largura da Saída </dt>
<dd> A largura em bits da saída. </dd>
<dt> Tipo da Extensão </dt>
<dd> Se a largura dos bits à saída puderem exceder aquela à entrada,
esse atributo irá configurar como deverão ser os bits adicionais da saída.
Se <q>Zero</q> ou <q>Um</q>, os bits adicionais serão 0 ou 1 respectivamente.
Se <q>Sinal</q>, os bits adicionais serão tomados de acordo com o bit de mais alta ordem
da entrada. E se <q>Entrada</q>, o componente usará o valor de uma segunda entrada
adicional na face norte. </dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Extensor de Bits</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/extender.gif" width="32" height="32">
<em>Extensor de Bits</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.5.0</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/extender.png" width="44" height="42"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> O extensor de bits transformará um valor em outro de largura diferente.
Se for para transformar para uma largura menor, os bits de mais baixa ordem
serão simplesmente truncados. Se for para transformar para uma largura maior,
os bits menos significativos serão os mesmos, e você terá uma escolha para os
bits de mais alta ordem: eles poderão ser todos iguais a 0, ou todos iguais a 1,
o concordarem com a entrada do <q>bit de sinal</q> (o mais significativo), ou
ainda ter esse valor determinado por uma entrada adicional.
</p>
<h2>Pinos</h2>
<dl>
<dt> Na face oeste (entrada, com largura em bits de acordo com o
atributo Largura da Entrada) </dt>
<dd><p> A entrada multibit cujo valor será transformado.</p></dd>
<dt> Na face leste (saída, com largura em bits de acordo com o
atributo Largura da Saída) </dt>
<dd><p> A saída calculada. </p></dd>
<dt> Na face norte (entrada, com largura de 1 bit) </dt>
<dd><p> Especificará como deverão ser os bits adicionais à saída.
Esse pino estará disponível apenas se o atributo Tipo da Extensão for
<q>Entrada.</q></p></dd>
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
os dígitos de '0 'a '9' poderão alterar o atributo <q> Largura da Entrada </q>,
Alt-0 até ALT-9 irão alterar o seu atributo <q> Largura da Saída</q>.
</p>
<dl>
<dt> Largura da Entrada </dt>
<dd> A largura em bits da entrada. </dd>
<dt> Largura da Saída </dt>
<dd> A largura em bits da saída. </dd>
<dt> Tipo da Extensão </dt>
<dd> Se a largura dos bits à saída puderem exceder aquela à entrada,
esse atributo irá configurar como deverão ser os bits adicionais da saída.
Se <q>Zero</q> ou <q>Um</q>, os bits adicionais serão 0 ou 1 respectivamente.
Se <q>Sinal</q>, os bits adicionais serão tomados de acordo com o bit de mais alta ordem
da entrada. E se <q>Entrada</q>, o componente usará o valor de uma segunda entrada
adicional na face norte. </dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

104
doc/pt/html/libs/base/index.html
View File

@ -1,52 +1,52 @@
<html>
<head>
<title>Biblioteca Base</title>
</head>
<body bgcolor="FFFFFF">
<h1>Biblioteca Base</h1>
<p> A biblioteca Base contém ferramentas de uso geral, assim como componentes
cujo comportamento é distinto de outros (ou seja, serão tratados de forma
singular pelo mecanismo de propagação do Logisim).
</p>
<table>
<tr><td align="right"><a href="poke.html"><img border="0" src="../../icons/poke.gif" width="16" height="16"></a></td>
<td><a href="poke.html">Ferramenta Testar</a></td></tr>
<tr><td align="right"><a href="edit.html"><img border="0" src="../../icons/select.gif" width="16" height="16"></td>
<td><a href="edit.html">Ferramenta Editar</td></tr>
<tr><td align="right"><a href="select.html"><img border="0" src="../../icons/select.gif" width="16" height="16"></td>
<td><a href="select.html">Ferramenta Selecionar</td></tr>
<tr><td align="right"><a href="wiring.html"><img border="0" src="../../icons/wiring.gif" width="16" height="16"></a></td>
<td><a href="wiring.html">Ferramenta Conectar</a></td></tr>
<tr><td align="right"><a href="text.html"><img border="0" src="../../icons/text.gif" width="16" height="16"></a></td>
<td><a href="text.html">Ferramenta Texto</a></td></tr>
<tr><td align="right"><a href="menu.html"><img border="0" src="../../icons/menu.gif" width="16" height="16"></a></td>
<td><a href="menu.html">Ferramenta Menu</a></td></tr>
<tr><td align="right"><a href="splitter.html"><img border="0" src="../../icons/splitter.gif" width="16" height="16"></a></td>
<td><a href="splitter.html">Distribuidor</a></td></tr>
<tr><td align="right"><a href="pin.html" style="text-decoration: none">
<img border="0" src="../../icons/pinInput.gif" width="16" height="16">
<img border="0" src="../../icons/pinOutput.gif" width="16" height="16"></a></td>
<td><a href="pin.html">Pino</a></td></tr>
<tr><td align="right"><a href="probe.html"><img border="0" src="../../icons/probe.gif" width="16" height="16"></a></td>
<td><a href="probe.html">Ponta de Prova</a></td></tr>
<tr><td align="right"><a href="tunnel.html"><img border="0" src="../../icons/tunnel.gif" width="16" height="16"></a></td>
<td><a href="tunnel.html">Túnel</a></td></tr>
<tr><td align="right"><a href="pull.html"><img border="0" src="../../icons/pullshap.gif" width="16" height="16"></a>
<img border="0" src="../../icons/pullrect.gif" width="16" height="16"></a></td>
<td><a href="pull.html">Resistor Pull</a></td></tr>
<tr><td align="right"><a href="clock.html"><img border="0" src="../../icons/clock.gif" width="16" height="16"></a></td>
<td><a href="clock.html">Clock</a></td></tr>
<tr><td align="right"><a href="extender.html"><img border="0" src="../../icons/extender.gif" width="16" height="16"></a></td>
<td><a href="extender.html">Extensor de Bits</a></td></tr>
<tr><td align="right"><a href="label.html"><img border="0" src="../../icons/text.gif" width="16" height="16"></a></td>
<td><a href="label.html">Rótulo</a></td></tr>
</table>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Biblioteca Base</title>
</head>
<body bgcolor="FFFFFF">
<h1>Biblioteca Base</h1>
<p> A biblioteca Base contém ferramentas de uso geral, assim como componentes
cujo comportamento é distinto de outros (ou seja, serão tratados de forma
singular pelo mecanismo de propagação do Logisim).
</p>
<table>
<tr><td align="right"><a href="poke.html"><img border="0" src="../../icons/poke.gif" width="16" height="16"></a></td>
<td><a href="poke.html">Ferramenta Testar</a></td></tr>
<tr><td align="right"><a href="edit.html"><img border="0" src="../../icons/select.gif" width="16" height="16"></td>
<td><a href="edit.html">Ferramenta Editar</td></tr>
<tr><td align="right"><a href="select.html"><img border="0" src="../../icons/select.gif" width="16" height="16"></td>
<td><a href="select.html">Ferramenta Selecionar</td></tr>
<tr><td align="right"><a href="wiring.html"><img border="0" src="../../icons/wiring.gif" width="16" height="16"></a></td>
<td><a href="wiring.html">Ferramenta Conectar</a></td></tr>
<tr><td align="right"><a href="text.html"><img border="0" src="../../icons/text.gif" width="16" height="16"></a></td>
<td><a href="text.html">Ferramenta Texto</a></td></tr>
<tr><td align="right"><a href="menu.html"><img border="0" src="../../icons/menu.gif" width="16" height="16"></a></td>
<td><a href="menu.html">Ferramenta Menu</a></td></tr>
<tr><td align="right"><a href="splitter.html"><img border="0" src="../../icons/splitter.gif" width="16" height="16"></a></td>
<td><a href="splitter.html">Distribuidor</a></td></tr>
<tr><td align="right"><a href="pin.html" style="text-decoration: none">
<img border="0" src="../../icons/pinInput.gif" width="16" height="16">
<img border="0" src="../../icons/pinOutput.gif" width="16" height="16"></a></td>
<td><a href="pin.html">Pino</a></td></tr>
<tr><td align="right"><a href="probe.html"><img border="0" src="../../icons/probe.gif" width="16" height="16"></a></td>
<td><a href="probe.html">Ponta de Prova</a></td></tr>
<tr><td align="right"><a href="tunnel.html"><img border="0" src="../../icons/tunnel.gif" width="16" height="16"></a></td>
<td><a href="tunnel.html">Túnel</a></td></tr>
<tr><td align="right"><a href="pull.html"><img border="0" src="../../icons/pullshap.gif" width="16" height="16"></a>
<img border="0" src="../../icons/pullrect.gif" width="16" height="16"></a></td>
<td><a href="pull.html">Resistor Pull</a></td></tr>
<tr><td align="right"><a href="clock.html"><img border="0" src="../../icons/clock.gif" width="16" height="16"></a></td>
<td><a href="clock.html">Clock</a></td></tr>
<tr><td align="right"><a href="extender.html"><img border="0" src="../../icons/extender.gif" width="16" height="16"></a></td>
<td><a href="extender.html">Extensor de Bits</a></td></tr>
<tr><td align="right"><a href="label.html"><img border="0" src="../../icons/text.gif" width="16" height="16"></a></td>
<td><a href="label.html">Rótulo</a></td></tr>
</table>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

172
doc/pt/html/libs/base/label.html
View File

@ -1,86 +1,86 @@
<html>
<head>
<title>Rótulo</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/text.gif" width="32" height="32">
<em>Rótulo</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/label.png" width="59" height="10"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Um rótulo simples com texto poderá ser colocado em qualquer lugar de um circuito.
Ele não irá interagir de forma alguma com os valores que atravessarão o circuito,
exceto se impedir a sua visibilidade quando o circuito for desenhado.
</p>
<p> Diferente de todos os outros componentes nas bibliotecas predefinidas,
os rótulos poderão ser colocados em qualquer lugar da área de desenho;
eles não irão ajustar-se à grade.
</p>
<h2>Pinos</h2>
<p>Nenhum.</p>
<h2>Atributos</h2>
<dl>
<dt> Texto </dt>
<dd> O texto que aparecerá no rótulo. Esse valor poderá ser editado
na tabela de atributos ou, usando a ferramenta Texto, diretamente sobre
a área de desenho. </dd>
<dt> Fonte </dt>
<dd> A fonte a ser usada para traçar o rótulo. </dd>
<dt> Alinhamento Horizontal</dt>
<dd> A técnica para posicionamento horizontal do texto relativo à posição oficial
do rótulo (quando o mouse for clicado para criá-lo). "Esquerda" significa que o
texto deverá ser escrito de modo que a face esquerda esteja naquela posição;
"Direita" significa que o texto deverá ser escrito de modo que a face direita
esteja naquela posição; e "Central" significa que o texto deverá ser escrito
centralizado (horizontalmente) naquela posição.
</dd>
<dt> Alinhamento Vertical </dt>
<dd><p>A técnica para posicionamento vertical do texto relativo à posição oficial
do rótulo (quando o mouse for clicado para criá-lo). "Base" significa que a linha
de base deverá interceptar a posição; "Topo" significa que a parte de cima do texto
deverá interceptar a posição; "Fundo" significa que a parte de baixo do texto
deverá interceptar a posição; e "Centro" significa que o texto deverá ser
centralizado (verticalmente) na posição.
</p>
<p> A parte de cima e a de baixo do texto serão calculadas tomando por base
os valores ascendentes e descendentes do padrão da fonte; assim, mesmo se o
texto atual não contiver letras ascendentes (tal como em <em>b</em>) ou letras
descendentes (como em <em>g</em>), ainda assim os limites supostos para tais
letras serão considerados para fins de posicionamento vertical.
</p></dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Permite que o texto do rótulo seja editado.</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Rótulo</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/text.gif" width="32" height="32">
<em>Rótulo</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/label.png" width="59" height="10"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Um rótulo simples com texto poderá ser colocado em qualquer lugar de um circuito.
Ele não irá interagir de forma alguma com os valores que atravessarão o circuito,
exceto se impedir a sua visibilidade quando o circuito for desenhado.
</p>
<p> Diferente de todos os outros componentes nas bibliotecas predefinidas,
os rótulos poderão ser colocados em qualquer lugar da área de desenho;
eles não irão ajustar-se à grade.
</p>
<h2>Pinos</h2>
<p>Nenhum.</p>
<h2>Atributos</h2>
<dl>
<dt> Texto </dt>
<dd> O texto que aparecerá no rótulo. Esse valor poderá ser editado
na tabela de atributos ou, usando a ferramenta Texto, diretamente sobre
a área de desenho. </dd>
<dt> Fonte </dt>
<dd> A fonte a ser usada para traçar o rótulo. </dd>
<dt> Alinhamento Horizontal</dt>
<dd> A técnica para posicionamento horizontal do texto relativo à posição oficial
do rótulo (quando o mouse for clicado para criá-lo). "Esquerda" significa que o
texto deverá ser escrito de modo que a face esquerda esteja naquela posição;
"Direita" significa que o texto deverá ser escrito de modo que a face direita
esteja naquela posição; e "Central" significa que o texto deverá ser escrito
centralizado (horizontalmente) naquela posição.
</dd>
<dt> Alinhamento Vertical </dt>
<dd><p>A técnica para posicionamento vertical do texto relativo à posição oficial
do rótulo (quando o mouse for clicado para criá-lo). "Base" significa que a linha
de base deverá interceptar a posição; "Topo" significa que a parte de cima do texto
deverá interceptar a posição; "Fundo" significa que a parte de baixo do texto
deverá interceptar a posição; e "Centro" significa que o texto deverá ser
centralizado (verticalmente) na posição.
</p>
<p> A parte de cima e a de baixo do texto serão calculadas tomando por base
os valores ascendentes e descendentes do padrão da fonte; assim, mesmo se o
texto atual não contiver letras ascendentes (tal como em <em>b</em>) ou letras
descendentes (como em <em>g</em>), ainda assim os limites supostos para tais
letras serão considerados para fins de posicionamento vertical.
</p></dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Permite que o texto do rótulo seja editado.</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

136
doc/pt/html/libs/base/menu.html
View File

@ -1,68 +1,68 @@
<html>
<head>
<title>Ferramenta Menu</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/menu.gif" width="32" height="32">
<em>Ferramenta Menu</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
</table></p>
<h2>Comportamento</h2>
<p> A ferramenta Menu permitirá ao usuário acionar um menu <i>pop-up</i> para
os componentes que já existirem. Por padrão, ao clicar o botão da direita
ou de controle um componente abrirá seu <i>menu pop-up</i>; contudo
<a href="../../guide/opts/mouse.html">a guia do mouse</a> das
<a href="../../guide/opts/index.html">opções de projeto</a>
permitirá ao usuário configurar os botões do mouse para funcionar de forma
diferente.
</p>
<p> O menu <i>pop-up</i> para a maioria dos componentes terá dois itens.
</p>
<ul>
<li> Apagar: Removerá o componente do circuito.
<li> Mostrar atributos: colocará os atributos do componente na janela com a
tabela de atributos, de modo que seus valores possam ser vistos e alterados.
</ul>
<p> Para alguns componentes, no entanto, o menu poderá ter itens adicionais.
Subcircuitos (ou seja, instâncias de um circuito usado como uma "caixa-preta"
dentro de outro) são exemplos disso: além dos itens acima, o menu <i>pop-up</i>
incluirá mais um item.
</p>
<ul>
<li> Ver <var>XXX</var>: serve para trocar o <i>layout</i> do circuito que estiver
sendo visto e editado para o de um subcircuito. Os valores vistos no <i>layout</i>
serão parte da mesma hierarquia do supercircuito.
(Ver a seção '<a href="../../guide/subcirc/debug.html">Depurar subcircuitos</a>'
do <em>Guia do Usuário</em>.)
</ul>
<p> Outros componentes também poderão estender o menu <i>pop-up</i>.
Nas versões correntes das bibliotecas predefinidas do Logisim, os únicos
componentes que poderão fazê-lo serão a <a href="../mem/ram.html">RAM</a> e
<a href="../mem/rom.html">ROM</a>.
</p>
<h2>Atributos</h2>
<p>Nenhum.</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Ferramenta Menu</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/menu.gif" width="32" height="32">
<em>Ferramenta Menu</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
</table></p>
<h2>Comportamento</h2>
<p> A ferramenta Menu permitirá ao usuário acionar um menu <i>pop-up</i> para
os componentes que já existirem. Por padrão, ao clicar o botão da direita
ou de controle um componente abrirá seu <i>menu pop-up</i>; contudo
<a href="../../guide/opts/mouse.html">a guia do mouse</a> das
<a href="../../guide/opts/index.html">opções de projeto</a>
permitirá ao usuário configurar os botões do mouse para funcionar de forma
diferente.
</p>
<p> O menu <i>pop-up</i> para a maioria dos componentes terá dois itens.
</p>
<ul>
<li> Apagar: Removerá o componente do circuito.
<li> Mostrar atributos: colocará os atributos do componente na janela com a
tabela de atributos, de modo que seus valores possam ser vistos e alterados.
</ul>
<p> Para alguns componentes, no entanto, o menu poderá ter itens adicionais.
Subcircuitos (ou seja, instâncias de um circuito usado como uma "caixa-preta"
dentro de outro) são exemplos disso: além dos itens acima, o menu <i>pop-up</i>
incluirá mais um item.
</p>
<ul>
<li> Ver <var>XXX</var>: serve para trocar o <i>layout</i> do circuito que estiver
sendo visto e editado para o de um subcircuito. Os valores vistos no <i>layout</i>
serão parte da mesma hierarquia do supercircuito.
(Ver a seção '<a href="../../guide/subcirc/debug.html">Depurar subcircuitos</a>'
do <em>Guia do Usuário</em>.)
</ul>
<p> Outros componentes também poderão estender o menu <i>pop-up</i>.
Nas versões correntes das bibliotecas predefinidas do Logisim, os únicos
componentes que poderão fazê-lo serão a <a href="../mem/ram.html">RAM</a> e
<a href="../mem/rom.html">ROM</a>.
</p>
<h2>Atributos</h2>
<p>Nenhum.</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

262
doc/pt/html/libs/base/pin.html
View File

@ -1,131 +1,131 @@
<html>
<head>
<title>Pino</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/pinInput.gif" width="32" height="32">
<img align="center" src="../../icons/pinOutput.gif" width="32" height="32">
<em>Pino</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/pin.png" width="101" height="51"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Um pino pode ser uma saída ou uma entrada para um circuito,
dependendo do valor de seu atributo Saída?. Ao desenhar um pino, o Logisim
representará as saídas por círculos ou retângulos com bordas arredondadas,
e as entradas serão representadas por quadrados ou retângulos.
Em ambos os casos, os bits individuais do valor que for recebido ou
enviado será mostrada pelo componente (exceto quando for prévia de uma
impressão, quando o componente apenas informará quantos bits poderá
comportar).
</p>
<p> Um pino é conveniente para se interagir com um circuito, e os usuários
iniciantes do Logisim não precisarão usá-los necessariamente. Mas um usuário
que estiver construindo um circuito que use vários subcircuitos (como descrito
na seção '<a href="../../guide/subcirc/index.html">Subcircuitos</a>' do
<em>Guia do Usuário</em>) poderá usar pinos para especificar a interface entre
um circuito e um subcircuito. Em particular, o pino de um <i>layout</i> de circuito
define como ele aparecerá quando for tomado por subcircuito e seu <i>layout</i> estiver
sendo usado por outro. Em tal circuito, os valores enviados ou recebidos
por essas posições no subcircuito serão vinculados aos pinos internos
de seu <i>layout</i>.
</p>
<h2>Pinos</h2>
<p> O componente tem apenas um ponto de conexão, que poderá ser uma entrada
para o componente se for um pino de saída, ou uma saída para o componente
caso seja um pino de entrada. Em ambos os casos, sua largura em bits
irá corresponder ao atributo Bits de Dados, e sua posição será especificada
pelo atributo Direção.
</p>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
os dígitos de '0 'a '9' poderão alterar o atributo <q> Bits de Dados </q>,
Alt-0 até ALT-9 irá alterar o atributo <q> Direção </q> e
e Alt com as teclas com setas poderão alterar o seu atributo <q>Posição do Rótulo</q>.
</p>
<dl>
<dt> Direção </dt>
<dd> A face do componente onde sua entrada/saída deverá estar. </dd>
<dt> Saída? </dt>
<dd> Serve para especificar se o componente irá funcionar com entrada ou saída.
(Observar que se for um pino de entrada, então o pino irá funcionar como se sua
interface dentro do circuito fosse uma saída, e vice-versa.) </dd>
<dt> Bits de Dados </dt>
<dd> O número de bits para o valor que o pino pode tratar.</dd>
<dt> Tri-state? </dt>
<dd> Para um pino de entrada, serve para configurar se o usuário poderá
indicar que o pino poderá emitir valores indefinidos (ou seja, flutuantes).
Esse atributo lida apenas com a interface com o usuário; ele não terá
qualquer efeito sobre como o pino se comportará quanto o <i>layout</i>
do circuito for usado como um subcircuito.
Para um pino de saída, o atributo não terá efeito algum.</dd>
<dt> Comportamento para Ajuste </dt>
<dd> Para um pino de entrada, o atributo especificará como um valor flutuante
deverá ser tratado quando recebido por uma entrada, talvez de um circuito que
esteja usando o <i>layout</i>, como no caso de um subcircuito. Se "imutável",
os valores flutuantes serão enviados como tal; se "<i>pull-up</i>", eles serão
convertidos para 1 antes de serem submetidos; e se "<i>pull-down</i>",
eles serão convertidos para 0 antes de serem entregues.
</dd>
<dt> Rótulo </dt>
<dd> O texto para o rótulo associado ao componente. </dd>
<dt> Posição do Rótulo</dt>
<dd> A posição do rótulo em relação ao componente.</dd>
<dt> Fonte do Rótulo </dt>
<dd> A fonte com a qual o rótulo será mostrado. </dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Ao clicar em um pino de saída não terá efeito algum, embora os atributos do
pino sejam apresentados.
</p>
<p> Ao clicar em um pino de entrada irá alternar bit que for clicado. Se for um
pino <i>tri-state</i>, em seguida, o bit correspondente irá alternar entre eles.
</p>
<p> Se, no entanto, o usuário estiver consultando o estado de um subcircuito
conforme descrito em <a href="../../guide/subcirc/debug.html"> 'Depuração
de Subcircuitos' </a> do <em>Guia do Usuário</em>, então o valor do pino
ficará fixo em qualquer valor que o subcircuito que estiver recebendo do
circuito que o contiver. O usuário não poderá alterar o valor sem quebrar
o vínculo entre os estados do subcircuito e o do circuito, e o Logisim pedirá
ao usuário para verificar se a quebra desse vínculo é realmente desejada.
</p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Permite que o rótulo associado ao componente seja editado.</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Pino</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/pinInput.gif" width="32" height="32">
<img align="center" src="../../icons/pinOutput.gif" width="32" height="32">
<em>Pino</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/pin.png" width="101" height="51"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Um pino pode ser uma saída ou uma entrada para um circuito,
dependendo do valor de seu atributo Saída?. Ao desenhar um pino, o Logisim
representará as saídas por círculos ou retângulos com bordas arredondadas,
e as entradas serão representadas por quadrados ou retângulos.
Em ambos os casos, os bits individuais do valor que for recebido ou
enviado será mostrada pelo componente (exceto quando for prévia de uma
impressão, quando o componente apenas informará quantos bits poderá
comportar).
</p>
<p> Um pino é conveniente para se interagir com um circuito, e os usuários
iniciantes do Logisim não precisarão usá-los necessariamente. Mas um usuário
que estiver construindo um circuito que use vários subcircuitos (como descrito
na seção '<a href="../../guide/subcirc/index.html">Subcircuitos</a>' do
<em>Guia do Usuário</em>) poderá usar pinos para especificar a interface entre
um circuito e um subcircuito. Em particular, o pino de um <i>layout</i> de circuito
define como ele aparecerá quando for tomado por subcircuito e seu <i>layout</i> estiver
sendo usado por outro. Em tal circuito, os valores enviados ou recebidos
por essas posições no subcircuito serão vinculados aos pinos internos
de seu <i>layout</i>.
</p>
<h2>Pinos</h2>
<p> O componente tem apenas um ponto de conexão, que poderá ser uma entrada
para o componente se for um pino de saída, ou uma saída para o componente
caso seja um pino de entrada. Em ambos os casos, sua largura em bits
irá corresponder ao atributo Bits de Dados, e sua posição será especificada
pelo atributo Direção.
</p>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
os dígitos de '0 'a '9' poderão alterar o atributo <q> Bits de Dados </q>,
Alt-0 até ALT-9 irá alterar o atributo <q> Direção </q> e
e Alt com as teclas com setas poderão alterar o seu atributo <q>Posição do Rótulo</q>.
</p>
<dl>
<dt> Direção </dt>
<dd> A face do componente onde sua entrada/saída deverá estar. </dd>
<dt> Saída? </dt>
<dd> Serve para especificar se o componente irá funcionar com entrada ou saída.
(Observar que se for um pino de entrada, então o pino irá funcionar como se sua
interface dentro do circuito fosse uma saída, e vice-versa.) </dd>
<dt> Bits de Dados </dt>
<dd> O número de bits para o valor que o pino pode tratar.</dd>
<dt> Tri-state? </dt>
<dd> Para um pino de entrada, serve para configurar se o usuário poderá
indicar que o pino poderá emitir valores indefinidos (ou seja, flutuantes).
Esse atributo lida apenas com a interface com o usuário; ele não terá
qualquer efeito sobre como o pino se comportará quanto o <i>layout</i>
do circuito for usado como um subcircuito.
Para um pino de saída, o atributo não terá efeito algum.</dd>
<dt> Comportamento para Ajuste </dt>
<dd> Para um pino de entrada, o atributo especificará como um valor flutuante
deverá ser tratado quando recebido por uma entrada, talvez de um circuito que
esteja usando o <i>layout</i>, como no caso de um subcircuito. Se "imutável",
os valores flutuantes serão enviados como tal; se "<i>pull-up</i>", eles serão
convertidos para 1 antes de serem submetidos; e se "<i>pull-down</i>",
eles serão convertidos para 0 antes de serem entregues.
</dd>
<dt> Rótulo </dt>
<dd> O texto para o rótulo associado ao componente. </dd>
<dt> Posição do Rótulo</dt>
<dd> A posição do rótulo em relação ao componente.</dd>
<dt> Fonte do Rótulo </dt>
<dd> A fonte com a qual o rótulo será mostrado. </dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Ao clicar em um pino de saída não terá efeito algum, embora os atributos do
pino sejam apresentados.
</p>
<p> Ao clicar em um pino de entrada irá alternar bit que for clicado. Se for um
pino <i>tri-state</i>, em seguida, o bit correspondente irá alternar entre eles.
</p>
<p> Se, no entanto, o usuário estiver consultando o estado de um subcircuito
conforme descrito em <a href="../../guide/subcirc/debug.html"> 'Depuração
de Subcircuitos' </a> do <em>Guia do Usuário</em>, então o valor do pino
ficará fixo em qualquer valor que o subcircuito que estiver recebendo do
circuito que o contiver. O usuário não poderá alterar o valor sem quebrar
o vínculo entre os estados do subcircuito e o do circuito, e o Logisim pedirá
ao usuário para verificar se a quebra desse vínculo é realmente desejada.
</p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Permite que o rótulo associado ao componente seja editado.</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

114
doc/pt/html/libs/base/poke.html
View File

@ -1,57 +1,57 @@
<html>
<head>
<title>Ferramenta Testar</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/poke.gif" width="32" height="32">
<em>Ferramenta Testar</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
</table></p>
<h2>Comportamento</h2>
<p> A ferramenta Testar (Poke) serve para manipular os valores correntes associados
aos componentes. O comportamento preciso da ferramenta Testar (Poke) irá variar
dependendo sobre qual componente for clicada; esse comportamento está documentado
na seção 'Comportamento da Ferramenta Testar (Poke)' de cada componente.
</p>
<blockquote><table>
<tr><td valign="top"><strong>Biblioteca Base</strong></td>
<td><a href="pin.html">Pino</a>
<br><a href="clock.html">Clock</a></td></tr>
<tr><td valign="top"><strong>Biblioteca Memória</strong></td>
<td><a href="../mem/flipflops.html">Flip-Flop D/T/J-K/S-R</a>
<br><a href="../mem/register.html">Registrador</a>
<br><a href="../mem/counter.html">Contador</a>
<br><a href="../mem/shiftreg.html">Registrador de Deslocamento</a>
<br><a href="../mem/ram.html">RAM</a>
<br><a href="../mem/rom.html">ROM</a></td></tr>
<tr><td valign="top"><strong>Biblioteca Entrada/Saída</strong></td>
<td><a href="../io/button.html">Botão</a>
<br><a href="../io/joystick.html">Joystick</a>
<br><a href="../io/keyboard.html">Teclado</a></td></tr>
<tr><td valign="top"><strong>Biblioteca Legada</strong></td>
<td><a href="../legacy/flipflops.html">Flip-Flops D/J-K do Logisim 1.0</a>
<br><a href="../legacy/register.html">Registrador de 8-bits do Logisim 1.0</a></td></tr>
</table></blockquote>
<p> Além disso, ao clicar em um segmento de fio usando a ferramenta Testar (Poke),
isso exibirá o valor corrente que passa por esse fio, como descrito na página
<a href="wiring.html">Ferramenta Conectar</a>.
</p>
<h2>Atributos</h2>
<p> Nenhum. Ao clicar em um componente que aceite a ferramenta Testar, então,
os atributos do componente serão exibidos. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Ferramenta Testar</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/poke.gif" width="32" height="32">
<em>Ferramenta Testar</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
</table></p>
<h2>Comportamento</h2>
<p> A ferramenta Testar (Poke) serve para manipular os valores correntes associados
aos componentes. O comportamento preciso da ferramenta Testar (Poke) irá variar
dependendo sobre qual componente for clicada; esse comportamento está documentado
na seção 'Comportamento da Ferramenta Testar (Poke)' de cada componente.
</p>
<blockquote><table>
<tr><td valign="top"><strong>Biblioteca Base</strong></td>
<td><a href="pin.html">Pino</a>
<br><a href="clock.html">Clock</a></td></tr>
<tr><td valign="top"><strong>Biblioteca Memória</strong></td>
<td><a href="../mem/flipflops.html">Flip-Flop D/T/J-K/S-R</a>
<br><a href="../mem/register.html">Registrador</a>
<br><a href="../mem/counter.html">Contador</a>
<br><a href="../mem/shiftreg.html">Registrador de Deslocamento</a>
<br><a href="../mem/ram.html">RAM</a>
<br><a href="../mem/rom.html">ROM</a></td></tr>
<tr><td valign="top"><strong>Biblioteca Entrada/Saída</strong></td>
<td><a href="../io/button.html">Botão</a>
<br><a href="../io/joystick.html">Joystick</a>
<br><a href="../io/keyboard.html">Teclado</a></td></tr>
<tr><td valign="top"><strong>Biblioteca Legada</strong></td>
<td><a href="../legacy/flipflops.html">Flip-Flops D/J-K do Logisim 1.0</a>
<br><a href="../legacy/register.html">Registrador de 8-bits do Logisim 1.0</a></td></tr>
</table></blockquote>
<p> Além disso, ao clicar em um segmento de fio usando a ferramenta Testar (Poke),
isso exibirá o valor corrente que passa por esse fio, como descrito na página
<a href="wiring.html">Ferramenta Conectar</a>.
</p>
<h2>Atributos</h2>
<p> Nenhum. Ao clicar em um componente que aceite a ferramenta Testar, então,
os atributos do componente serão exibidos. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

162
doc/pt/html/libs/base/probe.html
View File

@ -1,81 +1,81 @@
<html>
<head>
<title>Ponta de Prova</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/probe.gif" width="32" height="32">
<em>Probe</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0.3</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/probe.png" width="39" height="52"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Uma ponta de prova é um elemento que simplesmente exibirá o valor em um dado
ponto de um circuito. Ela mesma não interage com os outros componentes.
</p>
<p> Na maioria dos aspectos, o componente ponta de prova é similar em funcionalidade
ao <a href="pin.html">componente Pino</a> configurado para saída.
A principal diferença é que se o circuito for usado como um subcircuito, então
um pino de saída fará parte daquela interface, enquanto a ponta de prova não.
Outra diferença é que a ponta de prova não possui um atributo Bits de Dados
para ser configurado: a largura em bits será inferida a partir de qualquer
valor que seja amostrado por sua entrada. Graficamente, elas são similares, mas
possuem bordas ligeiramente diferentes: um pino possui a borda em preto, mais
larga, enquanto a da ponta de prova será mais estreita, em cinza.
</p>
<h2>Pinos</h2>
<p> O componente ponta de prova tem apenas um pino, o qual servirá como entrada.
A largura em bits desse pino é adaptativa: a ponta de prova se ajustará a
entradas de qualquer largura.
</p>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
as teclas com setas poderão alterar o seu atributo <q> Direção</q>.
</p>
<dl>
<dt> Direção </dt>
<dd> A face do componente onde o seu pino de entrada deverá estar. </dd>
<dt> Rótulo </dt>
<dd> O texto para o rótulo associado ao componente. </dd>
<dt> Posição do Rótulo </dt>
<dd> A posição do rótulo em relação ao componente.</dd>
<dt> Fonte do Rótulo </dt>
<dd> A fonte com a qual o rótulo será mostrado. </dd>
<dt> Base </dt>
<dd> A base do sistema de numeração (por exemplo, binário, decimal, ou hexadecimal)
no qual o valor será exibido.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Permite que o rótulo associado ao componente seja editado.</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Ponta de Prova</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/probe.gif" width="32" height="32">
<em>Probe</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0.3</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/probe.png" width="39" height="52"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Uma ponta de prova é um elemento que simplesmente exibirá o valor em um dado
ponto de um circuito. Ela mesma não interage com os outros componentes.
</p>
<p> Na maioria dos aspectos, o componente ponta de prova é similar em funcionalidade
ao <a href="pin.html">componente Pino</a> configurado para saída.
A principal diferença é que se o circuito for usado como um subcircuito, então
um pino de saída fará parte daquela interface, enquanto a ponta de prova não.
Outra diferença é que a ponta de prova não possui um atributo Bits de Dados
para ser configurado: a largura em bits será inferida a partir de qualquer
valor que seja amostrado por sua entrada. Graficamente, elas são similares, mas
possuem bordas ligeiramente diferentes: um pino possui a borda em preto, mais
larga, enquanto a da ponta de prova será mais estreita, em cinza.
</p>
<h2>Pinos</h2>
<p> O componente ponta de prova tem apenas um pino, o qual servirá como entrada.
A largura em bits desse pino é adaptativa: a ponta de prova se ajustará a
entradas de qualquer largura.
</p>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
as teclas com setas poderão alterar o seu atributo <q> Direção</q>.
</p>
<dl>
<dt> Direção </dt>
<dd> A face do componente onde o seu pino de entrada deverá estar. </dd>
<dt> Rótulo </dt>
<dd> O texto para o rótulo associado ao componente. </dd>
<dt> Posição do Rótulo </dt>
<dd> A posição do rótulo em relação ao componente.</dd>
<dt> Fonte do Rótulo </dt>
<dd> A fonte com a qual o rótulo será mostrado. </dd>
<dt> Base </dt>
<dd> A base do sistema de numeração (por exemplo, binário, decimal, ou hexadecimal)
no qual o valor será exibido.</dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Permite que o rótulo associado ao componente seja editado.</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

148
doc/pt/html/libs/base/pull.html
View File

@ -1,74 +1,74 @@
<html>
<head>
<title>Resistor para Ajuste</title>
</head>
<body bgcolor="FFFFFF">
<h1>
<img align="center" src="../../icons/pullshap.gif" width="32" height="32">
<img align="center" src="../../icons/pullrect.gif" width="32" height="32">
<em>Resistor para Ajuste</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.5.0</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top">
<table><tbody>
<tr><td>Portas convencionais:</td>
<td><img src="../images/pull-shaped.png" width="40" height="15"></td></tr>
<tr><td>Portas retangulares:</td>
<td><img src="../images/pull-rect.png" width="40" height="15"></td></tr>
</tbody></table></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Quando conectado a um ponto, esse componente terá efeito apenas quando o valor
nesse ponto for flutuante (Z). Nesse caso, o resistor de ajuste fará com que a
conexão concorde com valor especificado pelo atributo<q> Direção de Ajuste</q>.
</p>
<p> Se estiver conectado a um valor multibit, então cada bit que estiver flutuando
será ajustado para a direção especificada, enquanto os bits, que não estiverem
flutuando, não serão alterados.
</p>
<h2>Pinos</h2>
<p> O resitor possui apenas um pino, que será uma saída e terá largura em bits
inferida do componente ao qual estiver conectado.
</p>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
as teclas com setas poderão alterar o seu atributo <q> Direção</q>.
</p>
<dl>
<dt> Direção </dt>
<dd> A direção do pino do componente em relação ao seu centro. </dd>
<dt> Direção para Ajuste </dt>
<dd> Serve para especificar para qual valor um sinal flutuante deverá ser ajustado.
Isso poderá ser para 0, 1, ou valor de erro. </dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Resistor para Ajuste</title>
</head>
<body bgcolor="FFFFFF">
<h1>
<img align="center" src="../../icons/pullshap.gif" width="32" height="32">
<img align="center" src="../../icons/pullrect.gif" width="32" height="32">
<em>Resistor para Ajuste</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.5.0</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top">
<table><tbody>
<tr><td>Portas convencionais:</td>
<td><img src="../images/pull-shaped.png" width="40" height="15"></td></tr>
<tr><td>Portas retangulares:</td>
<td><img src="../images/pull-rect.png" width="40" height="15"></td></tr>
</tbody></table></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Quando conectado a um ponto, esse componente terá efeito apenas quando o valor
nesse ponto for flutuante (Z). Nesse caso, o resistor de ajuste fará com que a
conexão concorde com valor especificado pelo atributo<q> Direção de Ajuste</q>.
</p>
<p> Se estiver conectado a um valor multibit, então cada bit que estiver flutuando
será ajustado para a direção especificada, enquanto os bits, que não estiverem
flutuando, não serão alterados.
</p>
<h2>Pinos</h2>
<p> O resitor possui apenas um pino, que será uma saída e terá largura em bits
inferida do componente ao qual estiver conectado.
</p>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
as teclas com setas poderão alterar o seu atributo <q> Direção</q>.
</p>
<dl>
<dt> Direção </dt>
<dd> A direção do pino do componente em relação ao seu centro. </dd>
<dt> Direção para Ajuste </dt>
<dd> Serve para especificar para qual valor um sinal flutuante deverá ser ajustado.
Isso poderá ser para 0, 1, ou valor de erro. </dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

202
doc/pt/html/libs/base/select.html
View File

@ -1,101 +1,101 @@
<html>
<head>
<title>Ferramenta Selecionar</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/select.gif" width="32" height="32">
<em>Ferramenta Selecionar</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Permite que componentes individuais possam ser colocados em uma mesma seleção.
Há certo número de ações possíveis com essa ferramenta.
<ul>
<li> Ao pressionar o botão do mouse enquanto ele estiver sobre um componente
selecionado, ele irá arrastar todos os componentes na mesma seleção.
</p>
<p> Por padrão, Logisim irá calcular uma forma de acrescentar novos fios
de modo que nenhuma conexão existente seja perdida durante o movimento.
(Às vezes, ele irá eliminar ou encurtar fios existentes.)
Se você estiver realizando um movimento em que você queira que essas alterações
sejam feitas, você poderá pressionar a tecla Shift durante a movimentação.
Se você quiser desabilitar esse comportamento por completo,
basta ir a Projeto &gt; Opções, selecionar a guia Área de Desenho,
e desmarcar a caixa <q> Manter Conexões ao Mover </q>;
nesse caso, as conexões serão calculadas somente quando a tecla <i>shift</i> for
<em>pressionada</em>.
</p>
<p> Ao arrastar uma seleção isso poderá levar a um comportamento inesperado dos fios:
se ao fazer isso, alguns fios passarem sobre outros, eles serão conectados,
e todos serão colocados na mesma seleção. Como resultado, se você arrastar a seleção
pela segunda vez, os fios que existirem previamente no local não serão deixados para
trás. Esse comportamento é necessário manter coerência com o comportamento esperado
para as conexões de fios no Logisim. E não constituirá, normalmente, um grande problema:
o Logisim irá traçar a seleção inteira no instante em que desejar efetivá-la,
e você não deverá fazê-lo, até que você tenha certeza que esteja no local correto.
</p>
<li><p> Caso contrário, ao clicar com o mouse em um componente apagará todos os
componentes na seleção, ao invés daquele(s) sobre onde houve a marcação.
</p></li>
<li><p> <i>Shift+click</i> do mouse sobre um componente alternará sua presença
na seleção. Se vários componentes compartilharem a mesma posição, a presença
de todos será alternada. Nada disso ocorrerá, porém, se for feito por outra ferramenta
(via a janela de opções de projeto <a href="../../guide/opts/mouse.html">
Guia do Mouse</a >).
</p></li>
<li><p> Ao começar a arrastar o mouse em uma posição que não contenha qualquer
componente, irá iniciar-se o traçado de uma área retangular para seleção.
Todos os componentes contidos dentro dessa área serão colocados na seleção.
</p></li>
<li><p> Ao clicar Shift e arrastar o mouse a partir de uma posição que não contiver
qualquer componente iniciará uma seleção retangular. A presença de todos os
componentes contidos nessa área será alternada. Isso não irá ocorrer,
porém, se a ação do mouse for mapeado para outra ferramenta em seu lugar.
</p></li>
</ul></p>
<p> Após selecionar os itens desejados, você poderá, naturalmente,
recortar/copiar/colar/apagar todos os itens via
<a href="../../guide/menu/edit.html"> menu Editar </a>.
</p>
<p> O comportamento do Logisim quando colar a área de transferência em um circuito
será um tanto peculiar: ele não irá colocar imediatamente os componentes no circuito,
em vez disso, a seleção será uma coleção de "esboços transparentes", que será deixada
no circuito assim que forem levados para outra posição ou removidos da seleção.
(Esse comportamento peculiar é necessário porque, caso contrário, as conexões na
seleção seriam fundidas àquelas no circuito atual de uma só vez, e não permitir que
pudessem ser arrastadas de sua posição anterior junto com o conteúdo da área de
transferência, até que fossem coladas onde o usuário desejasse.)
</p>
<h2>Atributos</h2>
<p> Nenhum. Ao selecionar um componente, seus atributos serão apresentados.
Se vários componentes forem selecionados, os atributos compartilhados por todos
serão mostrados, em branco ficarão aqueles com valores diferentes e
de outro modo os que tiverem em comum. (As conexões serão ignoradas,
se não houver qualquer outro componente na seleção.) Mudanças no valor do atributo
afetarão todos os componentes selecionados.
</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Ferramenta Selecionar</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/select.gif" width="32" height="32">
<em>Ferramenta Selecionar</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
</table></p>
<h2>Comportamento</h2>
<p> Permite que componentes individuais possam ser colocados em uma mesma seleção.
Há certo número de ações possíveis com essa ferramenta.
<ul>
<li> Ao pressionar o botão do mouse enquanto ele estiver sobre um componente
selecionado, ele irá arrastar todos os componentes na mesma seleção.
</p>
<p> Por padrão, Logisim irá calcular uma forma de acrescentar novos fios
de modo que nenhuma conexão existente seja perdida durante o movimento.
(Às vezes, ele irá eliminar ou encurtar fios existentes.)
Se você estiver realizando um movimento em que você queira que essas alterações
sejam feitas, você poderá pressionar a tecla Shift durante a movimentação.
Se você quiser desabilitar esse comportamento por completo,
basta ir a Projeto &gt; Opções, selecionar a guia Área de Desenho,
e desmarcar a caixa <q> Manter Conexões ao Mover </q>;
nesse caso, as conexões serão calculadas somente quando a tecla <i>shift</i> for
<em>pressionada</em>.
</p>
<p> Ao arrastar uma seleção isso poderá levar a um comportamento inesperado dos fios:
se ao fazer isso, alguns fios passarem sobre outros, eles serão conectados,
e todos serão colocados na mesma seleção. Como resultado, se você arrastar a seleção
pela segunda vez, os fios que existirem previamente no local não serão deixados para
trás. Esse comportamento é necessário manter coerência com o comportamento esperado
para as conexões de fios no Logisim. E não constituirá, normalmente, um grande problema:
o Logisim irá traçar a seleção inteira no instante em que desejar efetivá-la,
e você não deverá fazê-lo, até que você tenha certeza que esteja no local correto.
</p>
<li><p> Caso contrário, ao clicar com o mouse em um componente apagará todos os
componentes na seleção, ao invés daquele(s) sobre onde houve a marcação.
</p></li>
<li><p> <i>Shift+click</i> do mouse sobre um componente alternará sua presença
na seleção. Se vários componentes compartilharem a mesma posição, a presença
de todos será alternada. Nada disso ocorrerá, porém, se for feito por outra ferramenta
(via a janela de opções de projeto <a href="../../guide/opts/mouse.html">
Guia do Mouse</a >).
</p></li>
<li><p> Ao começar a arrastar o mouse em uma posição que não contenha qualquer
componente, irá iniciar-se o traçado de uma área retangular para seleção.
Todos os componentes contidos dentro dessa área serão colocados na seleção.
</p></li>
<li><p> Ao clicar Shift e arrastar o mouse a partir de uma posição que não contiver
qualquer componente iniciará uma seleção retangular. A presença de todos os
componentes contidos nessa área será alternada. Isso não irá ocorrer,
porém, se a ação do mouse for mapeado para outra ferramenta em seu lugar.
</p></li>
</ul></p>
<p> Após selecionar os itens desejados, você poderá, naturalmente,
recortar/copiar/colar/apagar todos os itens via
<a href="../../guide/menu/edit.html"> menu Editar </a>.
</p>
<p> O comportamento do Logisim quando colar a área de transferência em um circuito
será um tanto peculiar: ele não irá colocar imediatamente os componentes no circuito,
em vez disso, a seleção será uma coleção de "esboços transparentes", que será deixada
no circuito assim que forem levados para outra posição ou removidos da seleção.
(Esse comportamento peculiar é necessário porque, caso contrário, as conexões na
seleção seriam fundidas àquelas no circuito atual de uma só vez, e não permitir que
pudessem ser arrastadas de sua posição anterior junto com o conteúdo da área de
transferência, até que fossem coladas onde o usuário desejasse.)
</p>
<h2>Atributos</h2>
<p> Nenhum. Ao selecionar um componente, seus atributos serão apresentados.
Se vários componentes forem selecionados, os atributos compartilhados por todos
serão mostrados, em branco ficarão aqueles com valores diferentes e
de outro modo os que tiverem em comum. (As conexões serão ignoradas,
se não houver qualquer outro componente na seleção.) Mudanças no valor do atributo
afetarão todos os componentes selecionados.
</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

222
doc/pt/html/libs/base/splitter.html
View File

@ -1,111 +1,111 @@
<html>
<head>
<title>Distribuidor</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/splitter.gif" width="32" height="32">
<em>Distribuidor</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/splitter.png" width="24" height="25"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> O distribuidor cria uma correspondência entre um valor multibit e vários
subconjuntos separados de bits equivalentes. A despeito do seu nome, ele pode separar
tanto um valor multibit em partes, quanto combiná-las em um valor multibit
- de fato ele poderá fazer ambos de uma vez. Uma descrição mais completa dos
distribuidores poderá ser encontrada na seção
'<a href="../../guide/bundles/splitting.html">Distribuidores</a>' do
<em>Guia do Usuário</em>.
</p>
<p> O Logisim trata os distribuidores de forma especial ao propagar sinais
dentro de um circuito: enquanto todos os outros componentes precisam de um
atraso calculado para fins do seu comportamento na simulação, os sinais
propagados pelos distribuidores (assim como também pelas conexões) serão
transmitidos instantaneamente.
</p>
<p><strong>Nota:</strong> O termo <em>distribuidor</em> não é um termo
padronizado, é único do Logisim até onde eu saiba. Desconheço qualquer
termo padrão para tal conceito; o único termo que já ví foi <em>bus ripper</em>,
mas esse termo é desnecessariamente violento para o meu gosto.
</p>
<h2>Pinos</h2>
<p> Para distinguir entre os diversos pontos de conexão em um distribuidor,
irei referir-me à terminação com um ponto de conexão como sua
<em>extremidade combinada</em>, e aos múltiplos pontos de conexão do outro
lado como sua <em>extremidade dividida</em>.
</p>
<dl>
<dt> A extremidade combinada (entrada/saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Representará um valor combinado por todos os bits que forem transmitidos pelo
distribuidor.
<dt> A extremidade dividida (entrada/saída, com largura em bits calculada com base
nos atributos Bit <var>x</var>)
<dd> O número de extremidades divididas será especificado pelo atributo Distribuição,
e cada uma terá um índice que será no mínimo igual a zero e menor que o valor desse
atributo. Para cada terminação, todos os bits para os quais o Bit <var> x </var>
referir-se por seu índice, serão transmitidos através da extremidade, e a ordem
desses bits será a mesma na extremidade combinada.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
os dígitos de '0 'a '9' poderão alterar o atributo <q> Distribuição</q>,
Alt-0 até ALT-9 irão alterar ambos os atributos <q> Distribuição</q> e
<q> Largura de Bits à Entrada</q>, e as teclas com setas poderão
alterar o seu atributo <q> Direção</q>.
</p>
<dl>
<dt> Direção </dt>
<dd> A posição da extremidade dividida em relação à combinada. </dd>
<dt> Distribuição </dt>
<dd> O número de terminações em uma extremidade. </dd>
<dt> Largura em Bits à Entrada </dt>
<dd> A largura em bits da extremidade combinada. </dd>
<dt> Bit <var>x</var></dt>
<dd> O índice de uma terminação ao qual o bit <var>x</var> corresponder
na extremidade combinada. As terminações são indexadas a partir de 0 no
topo (para um distribuidor voltado para leste ou oeste) e a partir de 0
da esquerda/oeste (para um distribuidor voltado para norte ou sul). Um
bit pode ser especificado para não corresponder a qualquer uma das terminações.
Não há qualquer maneira pela qual um bit possa corresponder a múltiplas
terminações. </dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Distribuidor</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/splitter.gif" width="32" height="32">
<em>Distribuidor</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
<tr><td valign="top"><strong>Aparência:</strong></td>
<td valign="top"><img src="../images/splitter.png" width="24" height="25"></td></tr>
</table></p>
<h2>Comportamento</h2>
<p> O distribuidor cria uma correspondência entre um valor multibit e vários
subconjuntos separados de bits equivalentes. A despeito do seu nome, ele pode separar
tanto um valor multibit em partes, quanto combiná-las em um valor multibit
- de fato ele poderá fazer ambos de uma vez. Uma descrição mais completa dos
distribuidores poderá ser encontrada na seção
'<a href="../../guide/bundles/splitting.html">Distribuidores</a>' do
<em>Guia do Usuário</em>.
</p>
<p> O Logisim trata os distribuidores de forma especial ao propagar sinais
dentro de um circuito: enquanto todos os outros componentes precisam de um
atraso calculado para fins do seu comportamento na simulação, os sinais
propagados pelos distribuidores (assim como também pelas conexões) serão
transmitidos instantaneamente.
</p>
<p><strong>Nota:</strong> O termo <em>distribuidor</em> não é um termo
padronizado, é único do Logisim até onde eu saiba. Desconheço qualquer
termo padrão para tal conceito; o único termo que já ví foi <em>bus ripper</em>,
mas esse termo é desnecessariamente violento para o meu gosto.
</p>
<h2>Pinos</h2>
<p> Para distinguir entre os diversos pontos de conexão em um distribuidor,
irei referir-me à terminação com um ponto de conexão como sua
<em>extremidade combinada</em>, e aos múltiplos pontos de conexão do outro
lado como sua <em>extremidade dividida</em>.
</p>
<dl>
<dt> A extremidade combinada (entrada/saída, com largura em bits de acordo com o
atributo Bits de Dados) </dt>
<dd> Representará um valor combinado por todos os bits que forem transmitidos pelo
distribuidor.
<dt> A extremidade dividida (entrada/saída, com largura em bits calculada com base
nos atributos Bit <var>x</var>)
<dd> O número de extremidades divididas será especificado pelo atributo Distribuição,
e cada uma terá um índice que será no mínimo igual a zero e menor que o valor desse
atributo. Para cada terminação, todos os bits para os quais o Bit <var> x </var>
referir-se por seu índice, serão transmitidos através da extremidade, e a ordem
desses bits será a mesma na extremidade combinada.
</dl>
<h2>Atributos</h2>
<p> Quando o componente for selecionado ou estiver sendo acrescentado,
os dígitos de '0 'a '9' poderão alterar o atributo <q> Distribuição</q>,
Alt-0 até ALT-9 irão alterar ambos os atributos <q> Distribuição</q> e
<q> Largura de Bits à Entrada</q>, e as teclas com setas poderão
alterar o seu atributo <q> Direção</q>.
</p>
<dl>
<dt> Direção </dt>
<dd> A posição da extremidade dividida em relação à combinada. </dd>
<dt> Distribuição </dt>
<dd> O número de terminações em uma extremidade. </dd>
<dt> Largura em Bits à Entrada </dt>
<dd> A largura em bits da extremidade combinada. </dd>
<dt> Bit <var>x</var></dt>
<dd> O índice de uma terminação ao qual o bit <var>x</var> corresponder
na extremidade combinada. As terminações são indexadas a partir de 0 no
topo (para um distribuidor voltado para leste ou oeste) e a partir de 0
da esquerda/oeste (para um distribuidor voltado para norte ou sul). Um
bit pode ser especificado para não corresponder a qualquer uma das terminações.
Não há qualquer maneira pela qual um bit possa corresponder a múltiplas
terminações. </dd>
</dl>
<h2> Comportamento da ferramenta Testar </h2>
<p> Nenhum. </p>
<h2> Comportamento da ferramenta Texto </h2>
<p> Nenhum. </p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

142
doc/pt/html/libs/base/text.html
View File

@ -1,71 +1,71 @@
<html>
<head>
<title>Ferramenta Texto</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/text.gif" width="32" height="32">
<em>Ferramenta Texto</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
</table></p>
<h2>Comportamento</h2>
<p> A ferramenta Texto lhe permitirá criar e editar rótulos associados aos componentes.
Os componentes que dispõem de rótulos terão essa característica indicada na seção
'Comportamento da Ferramaneta Texto' de sua documentação. Até a presente versão,
os seguintes componentes das bibliotecas predefinidas oferecem rótulos:
</p>
<center><table>
<tr><td valign="top"><strong>Biblioteca Base</strong></td>
<td><a href="pin.html">Pino</a>
<br><a href="clock.html">Clock</a>
<br><a href="label.html">Rótulo</a>
<br><a href="probe.html">Ponta de Prova</a>
</td></tr>
<tr><td valign="top"><strong>Biblioteca Memória</strong></td>
<td><a href="../mem/flipflops.html">Flip-Flops D/T/JK/SR</a>
<br><a href="../mem/register.html">Registrador</a>
<br><a href="../mem/counter.html">Contador</a>
<br><a href="../mem/shiftreg.html">Registrador de Deslocament</a>
<br><a href="../mem/random.html">Gerador Aleatório</a>
</td></tr>
<tr><td valign="top"><strong>Biblioteca para Entrada/Saída</strong></td>
<td><a href="../io/button.html">Botão</a>
<br><a href="../io/led.html">LED</a>
</td></tr>
</table></center>
<p> Para os componentes que poderão ter um rótulo, mas que não o tiverem ainda,
você poderá clicar sobre ele e acrescentá-lo. Se já houver um rótulo, você
deverá clicar sobre o mesmo. Se você clicar em um ponto onde não houver rótulo
para ser editado, o Logisim irá acrescentar um componente novo do tipo Rótulo.
</p>
<p> Na atual versão do Logisim, as funcionalidades para a edição de texto
ainda são bastante primitivas.
Selecionar uma região do texto dentro do rótulo é impossível.
Não há como inserir uma quebra de linha dentro de um rótulo.
</p>
<h2>Atributos</h2>
<p> Os atributos dessa ferramenta são os mesmos do
<a href="label.html">componente Rótulo</a>. Esses atributos não terão efeito
algum quando se editar o rótulo de um componente que já exista, mas eles serão
transmitidos para quaisquer rótulos criados usando essa ferramenta.
</p>
<p> Ao clicar em um componente que ofereça suporte à ferramenta Texto,
isso fará com que os atributos do componente sejam apresentados.
</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>
<html>
<head> <meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Ferramenta Texto</title>
</head>
<body bgcolor="FFFFFF">
<h1><img align="center" src="../../icons/text.gif" width="32" height="32">
<em>Ferramenta Texto</em></h1>
<p><table>
<tr><td><strong>Biblioteca:</strong></td>
<td><a href="index.html">Base</a></td></tr>
<tr><td><strong>Introdução:</strong></td>
<td>2.0 Beta 1</td></tr>
</table></p>
<h2>Comportamento</h2>
<p> A ferramenta Texto lhe permitirá criar e editar rótulos associados aos componentes.
Os componentes que dispõem de rótulos terão essa característica indicada na seção
'Comportamento da Ferramaneta Texto' de sua documentação. Até a presente versão,
os seguintes componentes das bibliotecas predefinidas oferecem rótulos:
</p>
<center><table>
<tr><td valign="top"><strong>Biblioteca Base</strong></td>
<td><a href="pin.html">Pino</a>
<br><a href="clock.html">Clock</a>
<br><a href="label.html">Rótulo</a>
<br><a href="probe.html">Ponta de Prova</a>
</td></tr>
<tr><td valign="top"><strong>Biblioteca Memória</strong></td>
<td><a href="../mem/flipflops.html">Flip-Flops D/T/JK/SR</a>
<br><a href="../mem/register.html">Registrador</a>
<br><a href="../mem/counter.html">Contador</a>
<br><a href="../mem/shiftreg.html">Registrador de Deslocament</a>
<br><a href="../mem/random.html">Gerador Aleatório</a>
</td></tr>
<tr><td valign="top"><strong>Biblioteca para Entrada/Saída</strong></td>
<td><a href="../io/button.html">Botão</a>
<br><a href="../io/led.html">LED</a>
</td></tr>
</table></center>
<p> Para os componentes que poderão ter um rótulo, mas que não o tiverem ainda,
você poderá clicar sobre ele e acrescentá-lo. Se já houver um rótulo, você
deverá clicar sobre o mesmo. Se você clicar em um ponto onde não houver rótulo
para ser editado, o Logisim irá acrescentar um componente novo do tipo Rótulo.
</p>
<p> Na atual versão do Logisim, as funcionalidades para a edição de texto
ainda são bastante primitivas.
Selecionar uma região do texto dentro do rótulo é impossível.
Não há como inserir uma quebra de linha dentro de um rótulo.
</p>
<h2>Atributos</h2>
<p> Os atributos dessa ferramenta são os mesmos do
<a href="label.html">componente Rótulo</a>. Esses atributos não terão efeito
algum quando se editar o rótulo de um componente que já exista, mas eles serão
transmitidos para quaisquer rótulos criados usando essa ferramenta.
</p>
<p> Ao clicar em um componente que ofereça suporte à ferramenta Texto,
isso fará com que os atributos do componente sejam apresentados.
</p>
<p><a href="../index.html">Voltar à <em>Referência para bibliotecas</em></a></p>
</body>
</html>

Some files were not shown because too many files have changed in this diff Show More