<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Rodrigo Francisquini on Medium]]></title>
        <description><![CDATA[Stories by Rodrigo Francisquini on Medium]]></description>
        <link>https://medium.com/@francisquini?source=rss-4a0d0ff102c9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*OfG3wDmbs1nllTFy.</url>
            <title>Stories by Rodrigo Francisquini on Medium</title>
            <link>https://medium.com/@francisquini?source=rss-4a0d0ff102c9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 13:58:14 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@francisquini/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[JavaScript: Lidando com o assincronismo e amarrando com callback.]]></title>
            <link>https://medium.com/@francisquini/javascript-lidando-com-o-assincronismo-e-amarrando-com-callback-fac0a9cdb21f?source=rss-4a0d0ff102c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/fac0a9cdb21f</guid>
            <category><![CDATA[node-js-tutorial]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[callback]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[asynchronous]]></category>
            <dc:creator><![CDATA[Rodrigo Francisquini]]></dc:creator>
            <pubDate>Mon, 30 Mar 2020 04:59:52 GMT</pubDate>
            <atom:updated>2020-03-30T16:23:39.482Z</atom:updated>
            <content:encoded><![CDATA[<p>Eu aprendi a programar em C e acostumei com as coisas sendo executadas em sequência. Cada linha era executada no seu tempo e a linha seguinte seria executada SOMENTE quando a linha anterior terminasse. Isso funcionava muito bem e fazia muito sentido até eu conhecer o <strong>JavaScript </strong>e seu assincronismo. Ai virou uma bagunça.</p><p>As coisas pareciam ter vida própria e se executavam sozinhas do jeito que queriam. Demorou um tempo até eu entender o que estava acontecendo e como controlar tudo, mas depois que aprendi, passei a preferir muito mais execuções assíncronas do que síncronas. Nesse artigo vou mostrar alguns exemplos onde o assincronismo pode confundir — e muito- seu código e como lidar com isso. De forma geral: vamos usar <strong>callbacks </strong>e outras dicas para garantir que as coisas sejam executadas da forma como queremos e garantir a integridade dos dados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yDbPbMDxvf0sMFM-gbkKKg.jpeg" /></figure><p>Vamos começar com um código JavaScript extremamente simples:</p><pre>var nome = ‘Rodrigo’;<br>console.log(“Meu nome é: “, nome);</pre><pre>nome = ‘Francisquini’;<br>console.log(“Meu novo nome é: “, nome);</pre><p>O resultado é exatamente como esperamos:</p><pre><strong>Meu nome é Rodrigo<br>Meu novo nome é Francisquini</strong></pre><p>Vamos complicar um pouco mais e supor que a modificação do nome seja feita dentro de uma função — modificando o objeto enviado como parâmetro:</p><pre>function muda_nome(nome){<br>   var novonome = nome;<br>   novonome = &#39;Francisquini&#39;;<br>   return novonome;<br>}</pre><pre>var nome = ‘Rodrigo’;<br>console.log(“Meu nome é: “, nome);</pre><pre>nome = muda_nome(nome);<br>console.log(“Meu novo nome é: “, nome);</pre><p>O resultado:</p><pre><strong>Meu nome é Rodrigo<br>Meu novo nome é Francisquini</strong></pre><p>Ué, se o resultado é o mesmo, então as coisas são executadas em sequência? SIM! Mas isso não significa que uma linha “espera” a linha anterior terminar para só depois ser executada. E, para exemplificar isso, vamos supor que a função <strong>muda_nome() </strong>demore um pouco mais para devolver o resultado (e, com “um pouco”, eu quero dizer: <strong>1 MILÉSIMO DE SEGUNDO</strong>). Fica assim:</p><pre>function muda_nome(nome){<br>   var novonome = nome;<br>   setTimeout(function(){<br>      novonome = ‘Francisquini’;<br>    }, 1);<br>   return novonome;<br>}</pre><pre>var nome = ‘Rodrigo’;<br>console.log(“Meu nome é: “, nome);</pre><pre>nome = muda_nome(nome);<br>console.log(“Meu novo nome é: “, nome);</pre><p>Ah, mas <strong>1 MILÉSIMO DE SEGUNDO </strong>é rápido demais, o resultado será o mesmo… será?</p><pre><strong>Meu nome é Rodrigo<br>Meu novo nome é Rodrigo</strong></pre><p>Ok, por qual motivo o nome não foi modificado? Simples: o segundo <strong>console.log </strong>foi executado antes da função <strong>muda_nome()</strong> retornar o valor e modificar a variável <strong>nome</strong>. Lembra do <strong>1 MILÉSIMO DE SEGUNDO</strong>? então, é tempo demais.</p><p>Beleza, e como eu resolvo isso se eu quero imprimir o novo nome? Alguém pode pensar… “retorna o nome só depois de modificar então!”. Seria algo assim:</p><pre>function muda_nome(nome){<br>    var novonome = nome;<br>    setTimeout(function(){<br>       novonome = ‘Francisquini’;<br>       return novonome;<br>    }, 1);<br>}</pre><pre>var nome = ‘Rodrigo’;<br>console.log(“Meu nome é: “, nome);</pre><pre>nome = muda_nome(nome);<br>console.log(“Meu novo nome é: “, nome);</pre><p>Se eu estou esperando modificar o nome para depois retornar o valor, então agora deve funcionar né? bom… vamos ver o que acontece:</p><pre><strong>Meu nome é Rodrigo<br>Meu novo nome é undefined</strong></pre><p>Se a execução não esperou <strong>1 MILÉSIMO DE SEGUNDO</strong> para imprimir o segundo console, por que esperaria pela sua resposta? é simples: ele executou, se você não respondeu <strong>NADA</strong> a tempo, o problema é seu. Daí vem o <strong>undefined</strong>! Você chamou a função e não respondeu nada a tempo. Vamos arrumar isso e fazer funcionar. O que precisamos é de uma instrução que diga: <strong>DEPOIS</strong> que você modificar o nome, <strong>PRINTA</strong> ele pra mim. Vamos basicamente criar uma função que queremos que seja executada <strong>DEPOIS</strong> da modificação.</p><pre>function muda_nome(nome){<br>    var novonome = nome;<br>    setTimeout(function(){<br>       novonome = ‘Francisquini’;<br>       return novonome;<br>    }, 1);<br>}</pre><pre>function EXECUTA_DEPOIS(novonome){<br>   console.log(“Meu novo nome é: “, novonome);<br>}</pre><pre>var nome = ‘Rodrigo’;<br>console.log(“Meu nome é: “, nome);</pre><pre>nome = muda_nome(nome);<br>EXECUTA_DEPOIS(nome);</pre><p>Perceba, com calma, o que fizemos: criamos uma função <strong>EXECUTA_DEPOIS </strong>que queremos que seja executa <strong>DEPOIS</strong> da modificação do nome. Intuitivo, não? O resultado:</p><pre><strong>Meu nome é Rodrigo<br>Meu novo nome é undefined</strong></pre><p>Se você acompanhou o raciocínio até aqui, já entendeu por que não funcionou. Chamamos a função <strong>EXECUTA_DEPOIS</strong> passando como argumento a variável <strong>nome</strong> que não foi modificada a tempo pela função <strong>muda_nome</strong>. Ou seja: não vai funcionar assim. Se a execução não espera a função terminar, como podemos chamar a função <strong>EXECUTA_DEPOIS</strong>? E se a gente passasse uma instrução pra função <strong>muda_nome </strong>pedindo que, DEPOIS de modificar o nome, ela execute a função <strong>EXECUTA_DEPOIS</strong>?</p><p>Precisamos fazer com que a função <strong>muda_nome </strong>receba uma “instrução” do que fazer depois de ser executada. E, para isso, vamos passar a “instrução” como parâmetro. Fica assim:</p><pre>function muda_nome(nome, instrucao){<br>   var novonome = nome;<br>   setTimeout(function(){<br>      novonome = ‘Francisquini’;<br>      instrucao(novonome);<br>    }, 1);<br>}</pre><pre>function EXECUTA_DEPOIS(nome){<br>   console.log(“Meu novo nome é: “, nome);<br>}</pre><pre>var nome = ‘Rodrigo’;<br>console.log(“Meu nome é: “, nome);</pre><pre>nome = muda_nome(nome, EXECUTA_DEPOIS);</pre><p>Vamos ver o resultado:</p><pre><strong>Meu nome é Rodrigo<br>Meu novo nome é Francisquini</strong></pre><p>Ok, por que funcionou? simples: não temos um “return” mais, agora só chamamos a função <strong>EXECUTA_DEPOIS</strong> depois que o nome é modificado. E, para que a função <strong>muda_nome </strong>saiba que tem que fazer isso, enviamos a função <strong>EXECUTA_DEPOIS </strong>como parâmetro (a “instrução”). Simples, não? Essa “instrução” costuma ser chamada de <strong>callback </strong>(agora as coisas fizeram mais sentido né?). Além disso, não precisamos declarar a função de forma isolada e passar como parâmetro, podemos simplesmente declarar ela no parâmetro. Esse <strong>MESMO </strong>código, escrito de outra forma, ficaria assim:</p><pre>function muda_nome(nome, callback){<br>   var novonome = nome;<br>   setTimeout(function(){<br>      novonome = ‘Francisquini’;<br>      callback(novonome);<br>   }, 1);<br>}</pre><pre>var nome = ‘Rodrigo’;<br>console.log(“Meu nome é: “, nome);</pre><pre>nome = muda_nome(nome, function(nome){<br>   console.log(“Meu novo nome é: “, nome);<br>});</pre><p>Compare — com calma — os dois códigos e veja como são iguals, mudando apenas o nome do parâmetro <strong>instrucao </strong>para <strong>callback </strong>e a declaração da função <strong>EXECUTA_DEPOIS </strong>diretamente como parâmetro.</p><h3>Complicando um pouco as coisas!</h3><p>Agora que ficou um pouco mais claro como funcionam os <strong>callbacks</strong>, vamos ver um caso um pouco mais complicado. Suponhamos que agora temos 4 nomes e não apenas um. Algo assim:</p><pre>var nomes = [‘Rodrigo’, ‘João’, ‘Bruno’, ‘Vitor’];<br>console.log(nomes);</pre><p>O resultado será:</p><pre><strong>[ &#39;Rodrigo&#39;, &#39;João&#39;, &#39;Bruno&#39;, &#39;Vitor&#39; ]</strong></pre><p>Conforme o esperado, certo? Vamos complicar, claro. Vamos, novamente, modificar os nomes utilizando a mesma técnica que vimos anteriormente.</p><pre>function muda_nome(nome, callback){<br>   var novonome = nome;<br>   setTimeout(function(){<br>      novonome = ‘Francisquini’;<br>      callback(novonome);<br>    }, 1);<br>}</pre><pre>var nomes = [‘Rodrigo’, ‘João’, ‘Bruno’, ‘Vitor’];<br>console.log(nomes);</pre><pre>for (let i=0;i&lt;4;i++){<br>   muda_nome(nomes[i], function(novonome){<br>      nomes[i] = novonome;<br>    });<br>}<br>console.log(&quot;novos nomes: &quot;, nomes);</pre><p>O resultado:</p><pre><strong>[ &#39;Rodrigo&#39;, &#39;João&#39;, &#39;Bruno&#39;, &#39;Vitor&#39; ]</strong></pre><p>É aqui que você lembra lá de cima quando tentamos um <strong>console.log </strong>depois de mudar algo e não funcionou, e, para arrumar isso, passamos como <strong>callback</strong>. Então, vamos mudar o segundo <strong>console.log</strong> de posição, certo?</p><pre>function muda_nome(nome, callback){<br>   var novonome = nome;<br>   setTimeout(function(){<br>      novonome = ‘Francisquini’;<br>      callback(novonome);<br>    }, 1);<br>}</pre><pre>var nomes = [‘Rodrigo’, ‘João’, ‘Bruno’, ‘Vitor’];<br>console.log(nomes);</pre><pre>for (let i=0;i&lt;4;i++){<br>   muda_nome(nomes[i], function(novonome){<br>      nomes[i] = novonome;<br>      console.log(&quot;novos nomes: &quot;, nomes);<br>    });<br>}<br></pre><p>Nosso resultado será:</p><pre><strong>novos nomes:  [ &#39;Francisquini&#39;, &#39;João&#39;, &#39;Bruno&#39;, &#39;Vitor&#39; ]<br>novos nomes:  [ &#39;Francisquini&#39;, &#39;Francisquini&#39;, &#39;Bruno&#39;, &#39;Vitor&#39; ]<br>novos nomes:  [ &#39;Francisquini&#39;, &#39;Francisquini&#39;, &#39;Francisquini&#39;, &#39;Vitor&#39; ]<br>novos nomes:  [ &#39;Francisquini&#39;, &#39;Francisquini&#39;, &#39;Francisquini&#39;, &#39;Francisquini&#39; ]</strong></pre><p>Ok, mas 4 nomes iguais? e precisa mesmo imprimir toda hora? Vamos fazer 3 modificações aqui: fazer o novo nome depender da posição do vetor, o tempo de demora da função <strong>muda_nome </strong>será uma variável e vamos imprimir somente <strong>UMA</strong> vez, quando acabar, ok?</p><pre>function muda_nome(nome, i, callback){<br>   var tempo = 1;<br>   var novonome = nome;<br>   setTimeout(function(){<br>      novonome = ‘nome_’ + i;<br>      callback(novonome);<br>    }, tempo);<br>}</pre><pre>var nomes = [‘Rodrigo’, ‘João’, ‘Bruno’, ‘Vitor’];<br>console.log(nomes);</pre><pre>for (let i=0;i&lt;4;i++){<br>   muda_nome(nomes[i], i, function(novonome){<br>      nomes[i] = novonome;<br>      if(i===3) console.log(&quot;novos nomes: &quot;, nomes);<br>    });<br>}</pre><p>O resultado:</p><pre><strong>novos nomes:  [ &#39;nome_0&#39;, &#39;nome_1&#39;, &#39;nome_2&#39;, &#39;nome_3&#39; ]</strong></pre><p>Funcionou exatamente como o esperado, certo? sim, mas… perceba uma coisa: estamos assumindo, <strong>perigosamente</strong>, que a função <strong>muda_nome </strong>leva o <strong>MESMO </strong>tempo para <strong>QUALQUER</strong> entrada.</p><p>E se o tempo da execução da função também variasse de acordo com a entrada? Veja: algumas funções podem ser executadas rapidamente (tipo somar 1 + 1) ou mais lentamente (tipo somar 98693489608960854 + 98478570493245865904). Assim, vamos supor que para a entrada ‘<strong>Rodrigo</strong>’, a função demora <strong>MAIS</strong> do que para outras entradas… assim:</p><pre>function muda_nome(nome, i, callback){<br>   var tempo = 1;<br>   if(nome === &#39;Rodrigo&#39;) tempo = 10;<br>   var novonome = nome;<br>   setTimeout(function(){<br>      novonome = ‘nome_’ + i;<br>      callback(novonome);<br>    }, tempo);<br>}</pre><pre>var nomes = [‘Rodrigo’, ‘João’, ‘Bruno’, ‘Vitor’];<br>console.log(nomes);</pre><pre>for (let i=0;i&lt;4;i++){<br>   muda_nome(nomes[i], i, function(novonome){<br>      nomes[i] = novonome;<br>      if(i===3) console.log(&quot;novos nomes: &quot;, nomes);<br>    });<br>}</pre><p>Perceba: para qualquer entrada diferente de ‘Rodrigo’, a função levará 1 milésimo de segundo. Para a entrada ‘Rodrigo’, a função levará 10. O resultado será:</p><pre><strong>novos nomes:  [ &#39;Rodrigo&#39;, &#39;nome_1&#39;, &#39;nome_2&#39;, &#39;nome_3&#39; ]</strong></pre><p>O que aconteceu? simples: o <strong>FOR </strong>chegou na posição 3 antes dos 10 milésimos de segundos necessários para modificar o nome ‘Rodrigo’. Lembre-se: as coisas são assíncronas e ninguém espera por ninguém. Vamos supor um caso ainda mais complicado: a função demora um tempo <strong>ALEATÓRIO</strong> para cada entrada. Algo assim:</p><pre>function muda_nome(nome, i, callback){<br>   var tempo = Math.random() * 100;<br>   var novonome = nome;<br>   setTimeout(function(){<br>      novonome = ‘nome_’ + i;<br>      callback(novonome);<br>    }, tempo);<br>}</pre><pre>var nomes = [‘Rodrigo’, ‘João’, ‘Bruno’, ‘Vitor’];<br>console.log(nomes);</pre><pre>for (let i=0;i&lt;4;i++){<br>   muda_nome(nomes[i], i, function(novonome){<br>      nomes[i] = novonome;<br>      if(i===3) console.log(&quot;novos nomes: &quot;, nomes);<br>    });<br>}</pre><p>Perceba que CADA vez que você executar, terá um resultado diferente. No meu caso, meu resultado foi:</p><pre><strong>novos nomes:  [ &#39;Rodrigo&#39;, &#39;nome_1&#39;, &#39;Bruno&#39;, &#39;nome_3&#39; ]</strong></pre><p>Por que isso acontece? a resposta é simples: você não tem garantia <strong>NENHUMA </strong>de que ao chegar em “i===3”, você terá, de fato, terminado de modificar todos os nomes. Alguns já terminaram, outros não… lembre-se: as coisas são assíncronas e o tempo de execução é aleatório. Ninguém espera por ninguém. Como podemos resolver isso sem saber qual a ordem de modificação dos nomes? Sabemos de uma única coisa: temos 4 tarefas para realizar: modificar cada um dos nomes. Se, em vez de nos preocuparmos com a ordem de execução das coisas, nos preocuparmos somente em garantir que as 4 tarefas tenham sido executadas, as coisas ficaram mais fáceis. Considere o código a seguir:</p><pre>function muda_nome(nome, i, callback){<br>   var tempo = Math.random() * 100;<br>   var novonome = nome;<br>   setTimeout(function(){<br>      novonome = ‘nome_’ + i;<br>      callback(novonome);<br>    }, tempo);<br>}</pre><pre>var nomes = [‘Rodrigo’, ‘João’, ‘Bruno’, ‘Vitor’];<br>console.log(nomes);</pre><pre>var tarefas = 4;</pre><pre>for (let i=0;i&lt;4;i++){<br>   muda_nome(nomes[i], i, function(novonome){<br>      nomes[i] = novonome;<br>      tarefas = tarefas - 1;<br>      if(tarefas===0) console.log(&quot;novos nomes: &quot;, nomes);<br>    });<br>}</pre><p>O resultado:</p><pre><strong>novos nomes:  [ &#39;nome_0&#39;, &#39;nome_1&#39;, &#39;nome_2&#39;, &#39;nome_3&#39; ]</strong></pre><p>Funcionou! Perceba o que fizemos: criamos uma variável chamada “<strong>tarefas</strong>” para saber quantas coisas precisamos executar e, sempre que executamos uma delas, decrementamos a variável. Quando a variável chegar em 0, significa que terminamos. A ordem deixou de importar, não faz diferença a ordem na qual os nomes são alterados, desde que todos eles tenham sido modificados. Tire proveito do assincronismo pra se preocupar MENOS e não MAIS com as coisas.</p><p><strong>E as promises? </strong>Bom, vai ficar pra outra hora…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fac0a9cdb21f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Data Science: Do 0 à API.]]></title>
            <link>https://medium.com/@francisquini/data-science-do-0-%C3%A0-api-506e2aabf57f?source=rss-4a0d0ff102c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/506e2aabf57f</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[graph]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[amazon-web-services]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Rodrigo Francisquini]]></dc:creator>
            <pubDate>Sun, 29 Sep 2019 00:10:54 GMT</pubDate>
            <atom:updated>2019-09-29T00:37:30.257Z</atom:updated>
            <content:encoded><![CDATA[<p>Muita gente tem falado sobre Data Science nos últimos tempos. Mas, em termos práticos, como um projeto é feito do 0? Essa foi umas das perguntas que eu mais recebi nos últimos dias. Por isso, decidi criar esse post contando sobre um projeto que trabalhei nos últimos tempos. Infelizmente, não posso entrar em detalhes sobre o projeto, mas aproveitei a oportunidade para contar as fases e ferramentas utilizadas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*EsUx7gcXV0w3_NQy" /></figure><h3>Primeira fase: Entender o Problema</h3><p>Aqui vai a primeira ferramenta importante: o especialista no problema. Seja em uma empresa ou no mundo acadêmico, todo problema surge da necessidade de alguém resolver algo. Se o problema não é seu, mas você foi escalado pra resolver ele, busque mais informações com o especialista. No caso desse projeto, o especialista é um biólogo de um instituto de pesquisa. E a primeira fase consistiu de horas e horas de conversa. É isso mesmo. Você não precisa de conhecimento sobre o problema antes de começar a resolver. Seja curioso, pergunte tudo e anote todos os <strong>insights </strong>proporcionados pela conversa.</p><h3>Segunda fase: Entender os dados</h3><p>Uma coisa é alguém te contar um problema, outra é te entregar um arquivo enorme de dados. Meu conjunto de dados possuía 100.000 linhas com muita informação. Foram mais algumas horas pra entender os dados e identificar o que era, de fato, relevante para o problema.</p><h3>Terceira fase: O pré processamento</h3><p>Você precisa remover tudo aquilo que não é relevante para o problema. Para isso, eu utilizei o <a href="https://jupyter.org/"><strong>jupyter notebook</strong></a><strong> </strong>para criar scripts em <a href="https://www.python.org/"><strong>python</strong></a><strong> </strong>que filtrassem os dados conforme as necessidades do problema. Eu gosto de usar o <strong>jupyter</strong> por ser mais visível pra esse tipo de análise. Nessa fase do projeto eu também usei algumas bibliotecas para algumas necessidades específicas, por exemplo:</p><ol><li>Os dados estavam organizados em uma planilha Excel. Então, utilizei a biblioteca <a href="https://pandas.pydata.org/"><strong>pandas</strong></a><strong> </strong>para ler, manipular e filtrar os dados. Se você planeja iniciar algum projeto em Data Science com Python, essa biblioteca não pode ficar de fora.</li><li>Algumas colunas da planilha, em particular, eram numéricas. Uma parte do processamento era dependente do valor dessas colunas. Entretanto, alguns atributos eram calculados diversas vezes durante os experimentos e foi necessário realizar uma normalização desses valores. Nesse fase eu utilizei a biblioteca <a href="https://numpy.org/"><strong>numpy</strong></a><strong> </strong>para realizar os cálculos que precisei, como: média, desvio padrão, normalização de dados, etc.</li></ol><h3>Quarta fase: A modelagem</h3><p>Nesse momento eu possuía um conjunto de dados filtrado e enxuto: de 100.000 linhas, somente 1.000 passaram pelos filtros. Aproveito pra deixar aqui uma dica: não se prenda aos dados. Quanto menor a quantidade, melhor. Extraia somente o que é importante para resolver seu problema e não tenha medo de descartar o restante.</p><p>Os dados filtrados ainda não eram a resposta do problema e era hora de criar algoritmos de <strong>Machine Learning</strong> para resolver o problema. Mas antes, precisei modelar o conjunto de dados em um novo formato: <a href="https://www.ime.usp.br/~pf/algoritmos_em_grafos/aulas/grafos.html"><strong>Grafos.</strong></a> Fiz uso de outra biblioteca, chamada <a href="https://igraph.org/python/"><strong>igraph</strong></a>. Com o <strong>igraph</strong> eu fui capaz de criar redes complexas que representavam meu problema e continham todas as informações que estavam armazenadas no conjunto de dados.</p><h3>Quinta fase: Processamento com Machine Learning</h3><p>Os dados estavam modelados na forma de redes complexas e para encontrar a informação que iria resolver meu problema eu criei algoritmos que pudessem processar essas redes. Não vou entrar em detalhes sobre esses algoritmos, mas foram basicamente 2 códigos diferentes criados em <strong>Python</strong>.</p><ol><li>Agrupamento em Grafos: A missão do primeiro algoritmo era separar a rede em conjuntos que possuíssem características similares. Pra exemplificar: Imagina todos os amigos que você tem no Facebook. Isso poderia facilmente ser modelado em uma rede de relacionamentos. Um conjunto dessa rede seria, por exemplo, os alunos de uma mesma sala na faculdade. Existe toda uma área de pesquisa que trabalha em métodos de detecção de comunidades em redes.</li><li>Processamento de Sinais em Grafos: Lembram dos atributos que as linhas possuíam? Esses valores entraram na rede na forma de atributos nos nós da rede e também precisavam ser analisados. Para isso, eu criei outro código capaz de filtrar os atributos da rede utilizando teoria espectral. Os conceitos utilizados para criar esse algoritmo foram importados da matemática: <strong>Transformada de Fourier</strong>. Nessa fase precisei de algumas bibliotecas adicionais capazes de realizar cálculos complexos: <strong>scipy, sklearn</strong> e, novamente, <strong>numpy</strong>.</li></ol><p>Os dois algoritmos, em conjunto, foram capazes de analisar a rede e identificar as anomalias que estávamos buscando.</p><h3>Sexta Fase: Apresentação dos Resultados</h3><p>Se você não entendeu quase nada do que foi dito na etapa anterior, pode ficar tranquilo: o especialista na área também não entende. E é aqui que entra a sexta fase desse projeto. Você precisa mostrar os resultados obtidos sem precisar explicar em detalhes o que fez. O que interessa é a solução do problema, o resto ninguém quer ouvir ou não vai entender.</p><p>Novamente, utilizei algumas bibliotecas para criar gráficos que mostrassem os resultados relevantes para a aplicação e, para isso, utilizei a biblioteca <a href="https://matplotlib.org/"><strong>matplotlib</strong></a><strong> </strong>para gerar as imagens. Uma coisa pra ter em mente aqui: qualquer um deve ser capaz de entender os resultados obtidos sem entender COMO você obteve. É importante focar em apresentar os resultados da forma mais simples e direta possível. Lembre-se: resolver o problema sem enrolação.</p><h3>90% dos projetos acabam aqui, mas…</h3><p>Você criou algoritmos que processam os dados, resolvem o problema e geram os resultados em forma de gráficos. A maioria dos projetos acabam nessa fase, mas… e se você quiser disponibilizar essa solução para mais pessoas, sem que elas precisem de você para executar as análises? Resposta: <strong>AWS</strong>!</p><h3>Sétima fase: Criação de API</h3><p>Todo o código foi modularizado e hospedado no AWS. Eu utilizei alguns serviços da AWS para que, qualquer um autorizado, pudesse realizar essas análises de forma independente: O código foi hospedado no AWS Lambda e os arquivos necessários são lidos do AWS S3. A chamada para o código é intermediada pelo AWS API Gateway. Dessa forma, toda essa análise ficou disponível como uma API que pode ser integrada, futuramente, a um sistema web disponível para os usuários.</p><p>Esse projeto levou alguns meses, mas o resultado final foi impressionante. Os resultados obtidos com Machine Learning foram excelentes e a facilidade de submeter novas análises ao sistema garantiu a facilidade necessária para que o problema fosse resolvido. Resolver um problema não é somente encontrar a solução, mas fazer isso de forma rápida, objetiva e simples. Se você curtiu o conteúdo e ainda não me segue no <strong>Instagram</strong>, eu sempre posto algumas coisas por lá: <a href="https://www.instagram.com/francisquinidev/">@francisquinidev</a>. Se você já me segue, deixa um feedback no insta sobre esse post!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=506e2aabf57f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como eu hospedaria uma aplicação sem gastar muito?]]></title>
            <link>https://medium.com/@francisquini/como-eu-hospedaria-uma-aplica%C3%A7%C3%A3o-sem-gastar-muito-119cc6d7677?source=rss-4a0d0ff102c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/119cc6d7677</guid>
            <category><![CDATA[cloud-services]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[hosting]]></category>
            <category><![CDATA[elastic-beanstalk]]></category>
            <category><![CDATA[amazon-web-services]]></category>
            <dc:creator><![CDATA[Rodrigo Francisquini]]></dc:creator>
            <pubDate>Thu, 12 Sep 2019 00:03:04 GMT</pubDate>
            <atom:updated>2019-09-12T00:05:09.553Z</atom:updated>
            <content:encoded><![CDATA[<h3>Como hospedar uma aplicação sem gastar muito?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SckruPiOYLK_ZUO-vlScuQ.jpeg" /></figure><p>Esses dias me perguntaram: “<strong>se você estivesse desempregado, o que faria?</strong>”. Deixei de lado a possibilidade de procurar um emprego (totalmente válida) e pensei no lado do empreendedorismo pra dar essa resposta. Alguns passos do que eu faria:</p><ol><li>Buscaria por negócios e empresas da região ou de parentes e estudaria o seu funcionamento em busca de processos que poderiam ser automatizados/otimizados.</li><li>Desenvolveria uma aplicação simples que atendesse às demandas dessa empresa, proporcionando uma melhoria nos processos envolvidos. Essa é uma oportunidade de criar algo útil, aprender novas tecnologias/aplicações e gerar portfólio.</li><li>Colocaria a aplicação online e ofereceria para a empresa, em modo experimental gratuito. Essa é uma boa estratégia pra validar, coletar feedback e aplicar melhorias até que a aplicação seja útil para a empresa.</li><li>Após a fase experimental, eu cobraria uma taxa mensal da empresa para continuar utilizando e ofereceria a aplicação para outras empresas que tenham problemas parecidos.</li></ol><p>Talvez nenhuma empresa aceite sua proposta? Sim, mas não vai saber se não tentar. Mesmo se receber um não, você ganhou experiência, conhecimento e portfólio. Um ponto importante dessa ideia é: <strong>se eu estou desempregado, como posso manter um sistema online sem gastar muito? </strong>A Amazon oferece um nível gratuito de 12 meses após o cadastro inicial para testar os serviços. É justamente por esse caminho que eu iria.</p><p>Eu utilizaria o <strong>AWS Elastic Beanstalk </strong>para hospedar a aplicação. O <strong>AWS Elastic Beanstalk</strong> é um serviço para implantação de aplicações desenvolvidas com as principais linguagens, como Java, PHP, Python, Ruby, Node.js, etc. Instâncias do tipo <strong>micro </strong>fazem parte do nível gratuito e são suficientes para a maioria das aplicações. O dia que uma instância micro não for suficiente para sua aplicação, você ficará feliz em pagar por uma melhor.</p><p>Ok, coloquei a aplicação online com o <strong>AWS Elastic Beanstalk</strong>, e o banco de dados? A Amazon oferece o <strong>RDS</strong> pra quem curte banco relacional, onde você consegue subir uma instância por 1 ano sem gastar nada. Pra quem curte banco não relacional, tem o <strong>DynamoDB </strong>que é gratuito até <strong>25 GB. </strong>Particularmente, eu uso o <strong>RDS </strong>pra bancos relacionais, mas nunca usei o <strong>DynamoDB</strong> pra não relacionais. Nesse último caso, eu prefiro usar o <strong>MongoDB</strong> fornecido pelo <strong>MLAB</strong>, que oferece um plano gratuito até 500 MB suficiente para a maior parte das aplicações teste.</p><p>Nesse momento sua aplicação já pode ficar online com um banco de dados, sem gastar nada por 1 ano. E o domínio? Aí tem que comprar. Geralmente um domínio custa por volta de R$ 30,00 e dura 1 ano. Sempre que eu compro um domínio, configuro os servidores <strong>DNS </strong>para apontarem para outro serviço da Amazon, o <strong>Route53</strong>. Você vai pagar uma taxa mensal por <strong>HostedZone</strong> que não vai passar de <strong>US$ 0,50</strong> na maioria dos casos (a não ser que sua aplicação tenha bilhões de requisições mensais, mas aí tudo bem pagar mais, né?).</p><p>Nesse momento sua aplicação ficou online, com banco de dados e um domínio próprio. O que falta? Toda aplicação tem arquivos para armazenar, seja imagens utilizadas no template ou arquivos carregados pelos usuários do sistema. Onde armazenar tudo isso? <strong>AWS S3</strong>. Você pode armazenar até <strong>5 GB </strong>no nível gratuito e não corre o risco de perder os arquivos dos seus usuários.</p><p>Uma última etapa (opcional) é incluir um <strong>certificado SSL</strong> no servidor. Ninguém gosta de acessar um site e receber o aviso de site inseguro. Aqui entra o maior custo, um certificado SSL ultrapassa facilmente <strong>R$ 300,00</strong> por ano. Mas, existem sites que fornecem um certificado de forma gratuita um período (3 meses, por exemplo). É uma forma de obter um certificado e ter tempo de validar a aplicação sem gastar essa taxa. Alguns sites oferecem certificado SSL totalmente grátis, mas eu nunca usei.</p><p>Com todos esses serviços você consegue colocar um sistema online gastando somente <strong>US$ 0,50 mensais </strong>de rota e <strong>R$ 30,00 anuais </strong>de domínio. Você ainda pode conseguir <strong>3 meses</strong> de certificado SSL <strong>grátis </strong>e validar sua aplicação sem gastar quase nada.</p><p><strong>E depois dos 3 meses?</strong> se você quiser continuar com sua aplicação, compra um <strong>certificado SSL</strong>.</p><p><strong>E quando acabar o Nível Gratuito? </strong>1 ano é suficiente pra validar a aplicação, né?</p><p>Eu também utilizo outros serviços nas minhas aplicações na AWS, como o Lambda, API Gateway, SES, Elastic Cache, Elastic Search, Cognito, EC2, etc. Mas nesse artigo listei os principais pra quem quer subir uma aplicação teste e ver no que dá. Se sentiu falta de algo, só deixar um comentário e fica pra um próximo artigo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=119cc6d7677" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Projetando um Processador Simples em Verilog]]></title>
            <link>https://medium.com/@francisquini/projetando-um-processador-simples-em-verilog-ea1b67f36da2?source=rss-4a0d0ff102c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea1b67f36da2</guid>
            <category><![CDATA[hardware]]></category>
            <category><![CDATA[fpga]]></category>
            <category><![CDATA[computer-architecture]]></category>
            <dc:creator><![CDATA[Rodrigo Francisquini]]></dc:creator>
            <pubDate>Fri, 22 Jun 2018 16:17:17 GMT</pubDate>
            <atom:updated>2018-06-22T18:55:02.311Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bMxjSzqLWM-dsdFKERiI5Q.png" /></figure><p>Quando comecei a projetar meu primeiro processador, perdi alguns dias tentando entender aqueles datapaths clássicos apresentados nos livros. Quando finalmente entendi, percebi que era mais fácil do que pensei e que não deveria ter perdido tanto tempo tentando entender o datapath completo. Era muito mais eficiente começar com um datapath simplificado.</p><p>Vamos começar com um processador extremamente simplificado. Nosso processador possuirá apenas o PC Counter, Memória de Instruções, Banco de Registradores, ULA e um módulo de saída. Basicamente, esses módulos são:</p><ul><li>PC COUNTER: O PC counter será, por hora, apenas um contador que inicia em 0.</li><li>INSTRUCTION MEMORY: A memória de instruções é apenas um vetor responsável por armazenar as instruções dos programas</li><li>REGISTER BANK: Assim como a memória de instruções, o banco de registradores também é um vetor utilizado para armazenamento rápido.</li><li>ULA: A ULA é responsável pelas operações que serão realizadas pelo processador.</li><li>OUTPUT: O módulo de saída será utilizado para exibir dados de saída.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dJjHINpXjpykkZwX.png" /></figure><h3>Formato de Instrução</h3><p>Vamos considerar instruções de 32 bits. Os bits, em ordem, representarão:</p><ul><li>5 bits: Opcode</li><li>5 bits: Registrador de Destino (REG D)</li><li>5 bits: Registrador de Operação 1 (REG R1)</li><li>5 bits: Registrador de Operação 2 (REG R2)</li><li>12 bits: Outras opções que não importam agora</li></ul><h3>O Projeto</h3><p>Para entender como os módulos serão conectados, vamos fazer algumas considerações:</p><ul><li>O opcode <strong>00001</strong> será referente a opção de adição.</li><li>Para simplificar, vamos considerar por hora que o registrador 0 já contém o valor 3 e o registrador 1 já contém o valor 5.</li><li>A nossa primeira instrução será: somar os valores dos registradores 0 (valor 3) e 1 (valor 5) e guardar o resultado no registrador 2.</li></ul><p>Assim, a primeira instrução é:</p><p>00001 (OPCODE) + 00010 (REG D) + 00000 (REG R1) + 00001 (REG R2) + 000000000000 = <strong>00001000100000000001000000000000</strong>.</p><p>Assim, a estrutura inicial do processador é:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ESbp04jXR3iqJfZe.png" /></figure><h3>Os caminhos</h3><p>Vamos criar os caminhos entre os módulos conforme necessidade. A primeira pergunta a ser respondida é: qual instrução o processador vai executar? Sabemos que a instrução está armazenada na posição 0 da memória de instruções. Precisamos fazer o processador saber que essa é a instrução que será executada. O responsável por essa informação é o PC Counter. Portanto, o primeiro caminho será entre o PC Counter e a Memória de Instruções.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fRT6Y9eagBGtekm-.png" /></figure><p>Agora, o processador já sabe qual instrução está sendo executada no momento. Como nessa instrução contém 3 registradores envolvidos, o banco de registradores precisa saber quais são esses registradores para poder fornecer os dados. Portanto, os próximos caminhos são os referentes aos registradores.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hhzAIiDgkQYhYh3a.png" /></figure><p>O próximo passo é fornecer para a ULA os valores necessários para que ela efetua a operação necessária. Além disso, também vamos fornecer o opcode da instrução para que a ULA saiba qual operação será realizada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oZRzVzsEqANnJoiu.png" /></figure><p>Nesse momento, a ULA já efetuou a operação. Agora precisamos armazenar o resultado da operação no registrador de destino. Para isso, precisamos criar um caminho que devolva o resultado da ULA para o banco de registradores. É esse valor que o banco de registradores guardará na posição de destino.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wxwPGJewSYFZIKNY.png" /></figure><p>Todo o processo foi concluído nesse momento. Todos os caminhos necessários para a operação de adição foram feitos. Para finalizar, vamos apenas criar um módulo simples de saída para exibir o valor armazenado no registrador de destino. Futuramente, esse módulo terá outras funcionalidades e existirá uma instrução específica de output de dados. Porém, por hora, o módulo apenas exibirá o valor armazenado no registrador D.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Y0Gr3upvCUuv8nOU.png" /></figure><h3>Começando com o Verilog</h3><p>Utilizando o Quartus, crie um novo projeto. Eu vou escolher o Device Cyclone 2 que é a placa que eu tenho, mas você pode escolher qualquer uma que queira.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IolqK0nKKpId2pbK.PNG" /></figure><h3>PC Counter</h3><p>Uma vez criado o projeto, vamos começar com os módulos. O primeiro módulo será o PC Counter. Para isso, crie um novo arquivo (FILE -&gt; NEW -&gt; Verilog HDL File) e salve como <strong><em>pc_counter.v</em></strong>. Esse arquivo será parecido com isso:</p><pre>module pc_counter</pre><pre>(clock, endereco);</pre><pre>input clock;<br>reg [31:0] counter;<br>output [31:0] endereco;</pre><pre>initial begin<br>  counter = 32&#39;b00000000000000000000000000000000;<br> end<br> <br>always @(negedge clock) begin<br> counter = counter + 32&#39;b00000000000000000000000000000001;<br>end</pre><pre>assign endereco = counter;</pre><pre>endmodule</pre><p>Vamos entender o código. Primeiramente, iniciamos o módulo com um valor de entrada (clock) e um valor de saída (endereço). Além disso, definimos um contador (counter) responsável por armazenar o valor do contador. Em seguida, declaramos o valor inicial do contador, que será 0. Após isso, sempre que o clock descer (NEGEDGE, ou seja, de 1 para 0), vamos incrementar o contador em 1. Finalmente, atribuimos o valor do contador para o valor de saída do módulo (endereco).</p><h3>Memória de Instruções</h3><p>Crie um novo arquivo (FILE -&gt; NEW -&gt; Verilog HDL File) e salve como <strong><em>memoria_instrucoes.v</em></strong>.</p><pre>module memoria_instrucoes</pre><pre>(counter, clock, instrucao_saida);</pre><pre>input clock;<br>input [31:0] counter;<br>output [31:0] instrucao_saida;</pre><pre>reg [31:0] memoria_instrucoes [99:0];</pre><pre>always @(posedge clock)<br>begin<br> memoria_instrucoes[0] &lt;= 32&#39;b00001000100000000001000000000000; <br>end</pre><pre>assign instrucao_saida = memoria_instrucoes[counter];</pre><pre>endmodule</pre><p>Novamente, iniciamos o módulo com os valores envolvidos. Agora, como entrada, temos o clock e o counter (que virá do PC Counter). Como saída, temos a instrução desejada. Além disso, criamos um vetor de 100 posições ([99:0]) para armazenar as instruções. Note que estamos escrevendo a instrução na posição 0 em todo ciclo de clock. Como saída, o valor instrucao_saida será a instrução que se encontra na posição <strong>counter</strong>.</p><h3>Banco de Registradores</h3><p>Crie um novo arquivo (FILE -&gt; NEW -&gt; Verilog HDL File) e salve como <strong><em>banco_registradores.v</em></strong>.</p><pre>module banco_registradores</pre><pre>(clock, endereco_regd, endereco_reg1, endereco_reg2, data_in, valor_regd, valor_reg1, valor_reg2);</pre><pre>input clock;</pre><pre>input [4:0] endereco_regd;<br>input [4:0] endereco_reg1;<br>input [4:0] endereco_reg2;</pre><pre>input [31:0] data_in;</pre><pre>output [31:0] valor_regd;<br>output [31:0] valor_reg1;<br>output [31:0] valor_reg2;</pre><pre>reg [31:0] registradores[31:0];</pre><pre>initial begin<br> registradores[5&#39;b00000] = 32&#39;b00000000000000000000000000000011;<br> registradores[5&#39;b00001] = 32&#39;b00000000000000000000000000000101;<br>end</pre><pre>always @(posedge clock)<br>begin<br> registradores[endereco_regd] &lt;= data_in; <br>end</pre><pre>assign valor_regd = registradores[endereco_regd];<br>assign valor_reg1 = registradores[endereco_reg1];<br>assign valor_reg2 = registradores[endereco_reg2];<br>endmodule</pre><p>Note que agora temos mais conexões.</p><ul><li>clock</li><li>endereco_regd: Endereço do registrador de destino (virá da memória de instruções).</li><li>endereco_reg1: Endereço do registrador 1 (virá da memória de instruções).</li><li>endereco_reg2: Endereço do registrador 2 (virá da memória de instruções).</li><li>data_in: Valor de entrada que será armazenado no registrador de destino (virá da ULA).</li></ul><p>Além desses valores de entrada, temos os 3 valores de saída que serão os valores armazenados nos registradores de interesse (RD, R1 e R2). Por fim, declaramos o vetor de 32 posições que representa nossos 32 registradores.</p><p>Em seguida, colocamos os valores iniciais. O valor 3 no registrador 0 e o valor 5 no registrador 1. Após isso, sempre que o clock subir, vamos armazenar o valor <strong>data_in</strong> no registrador de destino. Finalmente, atribuitos os valores dos registradores como saída do módulo.</p><h3>ULA</h3><p>Crie um novo arquivo (FILE -&gt; NEW -&gt; Verilog HDL File) e salve como <strong><em>ula.v</em></strong>.</p><pre>module ula</pre><pre>(opcode, data1_in, data2_in, data_out);</pre><pre>input [31:0] data1_in;   <br>input [31:0] data2_in;<br>input [4:0] opcode;</pre><pre>output [31:0] data_out;</pre><pre>reg [31:0] result;</pre><pre>always @(data1_in or data2_in or opcode)<br>begin<br>  case(opcode)<br>   5&#39;b00001:<br>     result = data1_in + data2_in;<br>   default:<br>     result = 32&#39;b00000000000000000000000000000000;<br>  endcase<br>end</pre><pre>assign data_out = result;<br>endmodule</pre><p>Agora temos 3 valores de entrada e 1 de saída. Conforme o datapath exibido, os valores de entrada da ULA são: opcode, reg1 e reg2. Além disso, temos um registrados para armazenar o resultado das operações. Sempre que ocorrer alguma alteração nos dados de entrada, executaremos a operação. Note que caso o opcode seja <strong>00001</strong>, executaremos a adição. Em qualquer outro caso, o resultado será 0. Por fim, atribuimos o resultado para o valor de saída.</p><h3>OUTPUT</h3><p>Como, por enquanto, não usaremos o output para nada além de exibir o valor do Registrador de Destino, não precisamos criar esse módulo ainda.</p><h3>CPU</h3><p>Todos os módulos internos foram criados. Agora, precisamos criar o módulo CPU que será responsável por conectar todos os outros módulos. Crie um novo arquivo (FILE -&gt; NEW -&gt; Verilog HDL File) e salve como <strong><em>cpu.v</em></strong>.</p><pre>module cpu</pre><pre>(clock, valor_saida);</pre><pre>input clock;<br>output [31:0] valor_saida;</pre><pre>wire [31:0] counter;<br>wire [31:0] instrucao;<br>wire [31:0] data_ula;<br>wire [31:0] valor_regd;<br>wire [31:0] valor_reg1;<br>wire [31:0] valor_reg2;</pre><pre>pc_counter<br>( <br> clock, <br> counter<br>);</pre><pre>memoria_instrucoes memoria_instrucoes<br>(<br> counter, <br> clock,<br> instrucao<br>);</pre><pre>banco_registradores banco_registradores<br>(<br> clock,<br> instrucao[26:22],<br> instrucao[21:17],<br> instrucao[16:12],<br> data_ula,<br> valor_regd,<br> valor_reg1, <br> valor_reg2<br>);</pre><pre>ula ula<br>(<br> instrucao[31:27],<br> valor_reg1,<br> valor_reg2,<br> data_ula<br>);<br>assign valor_saida = valor_regd;<br>endmodule</pre><p>Agora, temos apenas um valor de entrada (o clock) e um valor de saída (o valor_saida). Em seguida, definimos as conexões que criamos no datapath. Ou seja, um fio para o contador, um para a instrucao, um para o valor de saída de ula e um para cada um dos três registradores.</p><p>Em seguida, instânciamos o primeiro módulo (PC Couter), passamos o clock como entrada e definimos que a saída será através do fio <strong>counter</strong>. O mesmo processo ocorre para o restante dos módulos, atribuindo os fios necessários.</p><p>Ao final do arquivo, atribuimos o valor do registrador de destino como saída do módulo.</p><h3>Testando o Projeto</h3><p>Primeiro, precisamos definir o arquivo <strong>cpu.v</strong> como o <strong>TOP LEVEL ENTITY</strong>. Para isso, seleciona a aba <strong>files</strong>, e, clicando com o botão esquerdo sob o arquivo <strong>cpu.v</strong>, clique em <strong>Set as Top Level Entity</strong>. Em seguida, compile o projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/303/0*6eaEY6A67sfGPGV2.PNG" /></figure><p>Eu não tenho a opção de Waveform disponível no meu Quartus. Porém, se você tiver, uma boa opção é criar um novo arquivo de teste. Note que só existirá um campo de entrada e um de saída. Nesse caso, basta você oscilar o clock e ver o que ocorre com o valor de saída. Se tudo ocorrer bem, o valor de saída será 8 após o primeiro clock.</p><p><em>Originally published at </em><a href="http://blog.francisquini.com/projetando-um-processador-simples/"><em>blog.francisquini.com</em></a><em> on June 22, 2018.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea1b67f36da2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A-C8V4 FPGA Development Board: Uma Visão Geral]]></title>
            <link>https://medium.com/@francisquini/a-c8v4-fpga-development-board-uma-vis%C3%A3o-geral-d3b224c7663e?source=rss-4a0d0ff102c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/d3b224c7663e</guid>
            <category><![CDATA[fpga]]></category>
            <category><![CDATA[fpga-programming]]></category>
            <category><![CDATA[hardware]]></category>
            <dc:creator><![CDATA[Rodrigo Francisquini]]></dc:creator>
            <pubDate>Wed, 30 May 2018 17:40:39 GMT</pubDate>
            <atom:updated>2018-05-30T17:57:48.867Z</atom:updated>
            <content:encoded><![CDATA[<p>Alguns anos atrás comecei a utilizar uma placa de desenvolvimento FPGA. Mais especificamente, a placa DE2–115 contendo Cyclone® IV E modelo EP4CE115 disponível na faculdade. Não demorou muito para eu pensar em comprar uma placa para mim. Infelizmente, o modelo chegava facilmente aos $600.00 e não era um investimento possível naquele momento. Decidi procurar alternativas com um custo menor, afinal, ainda estava iniciando.</p><p>Não demorou muito para que eu me deparasse com um modelo de baixo custo chamado A-C8V4. Ok, não é original e nem tampouco confiável. Além disso, seria necessário importar e passar por todo aquele processo demorado de entrega. Apesar disso, o preço era razoável e parecia possuir tudo que eu precisava naquele momento. Decidi arriscar e comprei.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/0*rzlM4CwFN30kSSEd.jpg" /></figure><p>Após alguns meses, o produto chegou (e foi taxado, claro). Animado, corri para desenvolver alguns projetos utilizando a recém chegada placa. A primeira decepção: não encontrei material de apoio, tampouco manual de instruções. O máximo que encontrei foram alguns documentos em chinês. Apesar disso, tentei arriscar alguns projetos e não deram certo. Desisti e guardei a placa em uma caixa.</p><p>Durante os próximos 3 anos utilizei o modelo disponível na faculdade para meus projetos. Porém, recentemente decidi dar uma segunda chance para a minha placa. O cenário era o mesmo: falta de material de apoio e quase nenhum projeto disponível online. Dessa vez persisti tentando utilizar a placa e consegui. Apesar de algumas dificuldades, consegui executar todos os projetos que havia desenvolvido na placa da faculdade na minha placa. Justamente por isso, decidi apresentar minha visão sobre essa placa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*YvRNID5w3iwZYYWo4owvuA.jpeg" /></figure><ol><li><strong>A placa não possui switches de entrada.</strong> Todos os meus projetos utilizando a DE2–115 utilizavam os switches disponíveis como forma de inserção de dados. A A-C8V4 não possui nenhum. Apesar de incômodo, isso está longe de ser um problema. É possível comprar switches buttons e conectá-los aos pinos I\O da placa perfeitamente. No meu caso, eu optei por utilizar um arduino e um teclado matricial conectados à placa como interface de entrada. Funcionou perfeitamente e é bem mais prático do que utilizar os switches da Cyclone® IV.</li><li><strong>Os displays de 7 segmentos devem ser multiplexados.</strong> Tanto a DE2–115, como a A-C8V4 possuem 8 displays de 7 segmentos. Porém, a DE2–115 possui 64 pinos para controlar os displays. Portanto, cada display pode ser controlado individualmente. Já a placa A-C8V4 possui somente 16 pinos para os 8 displays. Assim, é necessário utilizar um multiplexador para controlar os displays. Novamente, apesar de um certo incômodo para realizar as modificações, isso também não é um problema. Bastou criar um multiplexador e tudo estava resolvido.</li><li><strong>Uma quantidade menor de elementos lógicos.</strong> Ok, a DE2–115 possui Cyclone® IV e a A-C8V4 possui Cyclone® II. Evidente que a A-C8V4 é inferior. Esbarrei nessa limitação quando migrei os projetos e tive que realizar algumas modificações para encaixar tudo. Não foram muitas e foi até bom pois precisei otimizar meu projeto. No fim, não tive nenhuma perda de funcionalidade no projeto e tudo funcionou normalmente.</li><li><strong>Alguns pinos são compartilhados.</strong> Alguns pinos da placa são compartilhados e isso pode causar uma certa confusão na hora de realizar a pinagem. Por exemplo, alguns pinos de I\O eram compartilhados com os pinos que controlam o display de 7 segmentos. Demorou um tempo até que eu percebesse que esse era o motivo de algumas coisas sem sentidos acontecerem.</li><li><strong>A lógica é invertida.</strong> Exatamente. 1 é desligado e 0 é ligado. Aparentemente, os periféricos são controlados por um transistor PNP. Me deparei com esse incomodo quando meu buzzer emitia sons sempre que ligava a placa. Esse é um ponto importante pra considerar durante o desenvolvimento, mas nada que inviabilize seus projetos.</li><li><strong>Poucos Leds.</strong> Existem poucos leds na placa, e a maioria deles é ligado diretamente a alguns periféricos. Até onde eu sei, só existem 6 que podem ser utilizados.</li><li><strong>Não tem material e nem suporte.</strong> Foi muito difícil achar material online utilizando essa placa. Além de não existir manual de instruções, o único material que encontrei foi o <strong>Datasheet</strong> da placa. Apesar de ser um pouco confuso, dá pra usar. Quanto aos projetos, desenvolvi alguns por conta própria e deu tudo certo.</li></ol><p>Tem muita coisa que eu ainda não testei, como, por exemplo, RS232 e display LCD. Porém, para os projetos que desenvolvo a placa está me atendendo muito bem. Em geral, apesar de ser uma versão pouco confiável e importada, eu considero o custo-benefício muito bom. Para quem está começando com FPGA ou precisa desenvolver alguns projetos básicos de faculdade, considero uma boa escolha.</p><p>Eu integrei minha placa com um arduino para a interface de entrada de dados e um raspberry para comunicação de rede. Um próximo passo talvez seja testar a comunicação utilizando o protocolo RS232 e diminuir a quantidade de jumpers necessários. Em geral, estou satisfeito e sinto que deveria ter dado uma segunda chance para a placa mais cedo. A imagem a seguir é uma foto da minha placa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*p0A5Hjgrvl5nqBX1.jpg" /></figure><p><em>Originally published at </em><a href="http://blog.francisquini.com/a-c8v4-fpga-development-board-uma-visao-geral/"><em>blog.francisquini.com</em></a><em> on May 30, 2018.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3b224c7663e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>