DEV Community: Marlon

RubberDuck o que é, e como fazer um com o seu Arduino Leonardo (ou com esp32, RP Pico e etc)

Marlon — Thu, 25 Apr 2024 03:00:00 +0000

Como sempre peguei um hiato grande nos posts do blog, mas estamos de volta e hoje vamos falar de uma ferramenta que os hackermans adoram e que é extremamente fácil e útil de fazer, o famoso RubberDuck.

Mas antes...

Um Disclaimer

Antes de começar a falar sobre o RubberDuck, é importante dizer que este post é puramente informativo, você pode usar as informações aqui contidas para fins educacionais, de segurança ou para facilitar o seu dia a dia, mas não me responsabilizo por qualquer uso indevido das informações aqui existentes.

O que é um RubberDuck?

O RubberDuck é um dispositivo que é feito para parecer muito com um pendrive comum, mas que pode emular um teclado ou mouse e executar diferentes comandos no momento em que é conectado a um hardware.

Ele é muito utilizado para automação de tarefas, testes de segurança e até mesmo para ataques de acessos físicos ou engenharia social.

Sim o RubberDuck é uma metonímia, que é uma palavra difícil para dizer que uma marca ficou tão grande que o nome do produto virou sinônimo do produto em si, como é o caso da Gillette, Bombril e Xerox.
O nome de dispositivos que fazem o que o RubberDuck faz de maneira genérica são BadUSBs ou keystroke injectiors.

Como fazer o seu RubberDuck (ou BadUSB)?

Para fazer o seu RubberDuck você vai precisar de um microcontrolador que possa emular um teclado e a parte legal é que quase todos os microcontroladores modernos podem fazer isso, como o ESP32, Raspberry Pi Pico, ATmega32u4 (que é o micro controlador do Arduino Leonardo, Micro e Pro Micro), attiny85 (que é o microcontrolador do Digispark) e muitos outros.

Aqui vou usar a Arduino IDE para programar um Arduino Leonardo.

Abrindo a Arduino IDE, vamos apertar 'ctrl + shif + i' para abrir o gerenciador de bibliotecas e vamos instalar a biblioteca "Keyboard" que é a biblioteca que vamos usar para emular o teclado.

Feito isso vamos para o código, que é bem simples:


#include "Keyboard.h"

void setup() {
  Keyboard.begin();
}

void loop() {
    delay(1000);

    // Pressiona a tecla do Windows
    Keyboard.press(KEY_LEFT_GUI); // ou Keyboard.press(KEY_RIGHT_GUI); dependendo do teclado
    delay(100);
    // Solta a tecla do Windows
    Keyboard.release(KEY_LEFT_GUI); // ou Keyboard.release(KEY_RIGHT_GUI); dependendo do teclado

    delay(1000);

    Keyboard.print("Hyper");

    delay(1500);

    // Pressiona a tecla Control e 1
    Keyboard.press(KEY_LEFT_CTRL);
    Keyboard.press(49);
    delay(100);
    // SOlta as teclas Control e 1
    Keyboard.releaseAll();

    delay(2000);

    Keyboard.println("cowsay Hack_The_Planet");

    delay(200000);
}

Esse código faz o seguinte:

Pressiona a tecla do Windows
Digita "Hyper"
Pressiona a tecla Control e 1
Digita "cowsay Hack_The_Planet"

Lógico que você pode fazer muito mais do que isso, mas esse é um exemplo simples de como você pode fazer um RubberDuck.

E como eu disse antes, você pode usar qualquer microcontrolador que possa emular um teclado, então você pode fazer um RubberDuck com um ESP32, Raspberry Pi Pico, Digispark, etc.

Isso é tudo pessoal

Eu sei, esse foi um post pequeno, mas eu precisava sair do hiato de alguma forma e achei que esse post seria uma forma legal de fazer isso.

Logo eu volto aqui com mais posts e mais projetos, então fiquem ligados.

Até a próxima.

Começando com Verilog 2 - Instanciação de Módulos

Marlon — Sat, 30 Sep 2023 18:06:43 +0000

Opa, eae?

Curti muito a repercussão do último post e em especial muito obrigado a He4rt Developers, essa comunidade que participo faz uns 3 anos e que é sensacional, não deixe de entrar.

Porém, acredito que ainda tem mais algumas coisas a serem abordadas para que você comece bem com Verilog e principalmente tenha todo o conhecimento para gabaritar o HDLbits.

Bom, como o título já diz, esta é a parte dois do post “Começando com Verilog” então caso você não tenha lido a primeira parte, cola aqui nesse link primeiro:

https://dev.to/marlonhenq/comecando-com-verilog-13n0

Aumentando a complexidade ou subindo a abstração com a instanciação de módulos

Uma das principais coisas que acabei não dizendo no último post é que módulos podem instanciar outros módulos.

Os que possuem olhares muito atentos podem até ter percebido isso quando falei sobre Verilog Estrutural “O Verilog Estrutural cria sua lógica chamando portas como módulos.”, porém irei explicar mais detalhadamente agora.

Uma forma muito comum de se fazer um multiplexador em Verilog é usando o operador ternário:

module top_module(
    input a, b, sel,
    output out
    );


    assign out = sel ? b:a;
endmodule

Obs: Olha ai uma nova forma de declarar os inputs e outputs, no post passado eu repetia sempre a palavra input e output para cada entrada/saida, mas caso elas sejam iguais (isto é, possuem a mesma quantidade de bits) você pode apenas colocar virgulas (como sempre Verilog possui várias formas de fazer a mesma coisa).

Caso você não saiba o que é um multiplexador, ele nada mais é que um permutador de entradas. No caso os inputs “a” e “b” são as entradas do nosso multiplexador, a “sel” é a nossa porta seletora, caso “sel” receba 0 o que vem por “a” é direcionado a saída “out”, caso “sel” receba 1 o que vem de “b” será direcionado a “out”.

Ele pode ser descrito pela tabela:

A	B	Sel	Out
0	0	0	0
0	0	1	0
0	1	0	0
0	1	1	1
1	0	0	1
1	0	1	0
1	1	0	1
1	1	1	1

Aí está a representação do último código com “a” recebendo 1 (representado pelo verde), “b” recebendo 0 (vermelho) e “sel” recebendo 0, assim o valor de “a” é direcionado a “out”:

Mudando a entrada de “sel” para 1, temos o que vem por “b” indo para “out”:

Mas e se agora quisermos um multiplexador de 4 entradas?

Obviamente, vamos ter que aumentar nossas entradas para agora “a”, “b”, “c” e “d” nossa seleção “sel” também deve aumentar para 2 bits.

E um código que poderia resolver isso seria:

module top_module( 
    input a, b, c, d,
    input [1:0] sel,
    output out ); 

    assign out  = sel[1] ? (sel[0] ? d : c) : (sel[0] ? b : a);
endmodule

A representação deste código é:

De fato funciona, mas a legibilidade de ternários encadeados não é muito boa, e se quisermos então um multiplexador de 8 entradas? Ai sim, temos um grande problema, e uma forma mais elegante de fazer isso é instanciar módulos por outros módulos.

Para instanciar módulos dentro de outros módulos em Verilog a sintaxe é “nome_do_modulo nome_da_instanciação (entrada1, entrada2,… saida1…);”.

Vamos lá, tendo o multiplexador de 2 entradas podemos fazer um multiplexador de 4 entradas instanciando o de 2 entradas três vezes, segue o código:

module mux2( //multiplexador de 2 entradas já apresentado
    input a, b, sel,
    output out ); 

    assign out  = sel ? b:a;
endmodule

module mux4(//multiplexador de 4 entradas
    input a, b, c, d, 
    input [1:0] sel,
    output out ); 

    wire fio1, fio2;

    mux2 multiplexador1 (a, b, sel[0], fio1);
    mux2 multiplexador2 (c, d, sel[0], fio2);

    mux2 multiplexadorFinal (fio1, fio2, sel[1], out);

endmodule

Representação gráfica do modulo mux4:

Outra forma de instanciar módulos (mais verbosa, porém que prefiro) é a de repetir o nome das portas do módulo que está sendo instanciado dessa forma:

module mux4(
    input a, b, c, d, 
    input [1:0] sel,
    output out ); 

    wire fio1, fio2;

    mux2 multiplexador1 (.a(a), .b(b), .sel(sel[0]), .out(fio1));
    mux2 multiplexador2 (.a(c), .b(d), .sel(sel[0]), .out(fio2));

    mux2 multiplexadorFinal (.a(fio1), .b(fio2), .sel(sel[1]), .out(out));

endmodule

Assim, além de ficar mais claro como está sendo o roteamento, não é necessário utilizar a ordem das entradas e saídas do módulo original, é inclusive possível suprimir algumas destas (caso não for necessário para algum tipo de instanciação).

Aumentando muito a complexidade com a instanciação de N módulos via Generate For

Outro circuito muito comum é o de somador binário, ele basicamente tem 3 entradas, os dois dígitos que ira receber, e a entrada de “vai um” (cin), de saídas temos a saída da soma, além de uma saída de “vai um” (cout), para um próximo somador.

Um código para um somador binário de um único dígito é:

module adder(
    input a,b,
    input cin,
    output cout,
    output sum );

    assign sum  = (a ^ b ^ cin);
    assign cout = ((a & b) | (b & cin) | (cin & a));
endmodule

O somador binário de um bit é graficamente representado assim:

Um somador de 2 bits a partir da instanciação do somador simples pode ser:

module adder2(
    input [1:0] a, b,
    input cin,
    output cout,
    output [1:0] sum );

    adder ad1 (a[0], b[0], cin, coutIntern, sum[0]);
    adder ad2 (a[1], b[1], coutIntern, cout, sum[1]);

endmodule

Obs: Olha ai também uma forma nova de se declarar um wire! O fio “coutIntern” foi declarado de forma implícita, já que ele apenas é citado já sendo usado pelos módulos mesmo não sendo declarado formalmente com “wire coutIntern;” anteriormente.
Contudo, fique atento, apenas wires de um único bit podem ser declarados dessa forma.

E graficamente o somador de 2 bits fica assim:

E se agora quisermos um somador de 100 bits? Acho que seria muito trabalho repetir essas linhas 100 vezes, né?
E é mesmo, mas temos uma forma mais elegante de fazer isso, o Generate For.

O Generate nada mais é que um bloco onde se pode executar alguns comandos que após realizarem suas condições uma (ou mais) instância(s) de módulo(s) pode(m) ser(em) incorporada(s) (ou não) ao circuito.

Dentro do Generate pode se utilizar “ifs”, “cases” e (os mais utilizados) os “fors” que realizarão loops os quais cada interação pode instanciar módulos.

Falando pode parecer difícil, então vamos direto para o código que é bastante autoexplicativo:

module adder100( 
    input [99:0] a, b,
    input cin,
    output [99:0] cout,
    output [99:0] sum );

    genvar i;

    adder ad0(a[0], b[0], cin, cout[0], sum[0]);

     generate
        for (i = 1; i < 100; i = i + 1) begin
                adder ad (a[i], b[i], cout[i-1], cout[i], sum[i]);
        end
     endgenerate


endmodule

Após a criação do nosso módulo “adder100” e a declaração das nossas entradas e saídas, temos a criação de uma variável de geração “genvar” com o nome de “i”.

Após isso, o primeiro módulo de adder é instanciado (ad0), já que este precisa receber o valor de “cin” ele acaba por ficar fora do nosso loop de geração.
Porém, agora todos os nossos demais 99 módulos irão interagir com vetores, ou seja, podem ser gerados por um loop de geração.

Assim, vem o nosso for com declaração muito próxima de C, onde a cada interação é instanciado um módulo adder de um bit.

Obs: A utilização do for pode dar a entender a ideia de linguagens de programação de que cada interação é adicionado um módulo ao longo do tempo, mas isso é apenas uma automação para que não seja necessário escrever 100 linhas quase iguais de código.
No final, o que teremos é 100 módulos rodando ao mesmo tempo, como se fossem 100 CIs de adição binária em uma mesma placa. Blz?

E que fique a dica, essa é a resposta para o exercício Adder100i do HDLBits!

A visualização para esse circuito graficamente é:

Éhh… Bom, esse circuito é grande de mais para se visualizar e testar graficamente pelo DigitalJS. Em uma tela cheia o máximo que conseguimos ver é 15 instancias (de 100) e meu notebook sofreu para gerar essa simulação.

O que faremos para testar esse tipo de circuito, então?

Testes! Mais especificamente neste caso chamamos de “TestBench”, porém irei deixar isso para o próximo post!

Isso é tudo!

Como sempre, obrigado por ter lido este post até aqui!

Demais dúvidas, comentários e sugestões podem ser enviados aqui embaixo (para o pessoal do DevTo) ou lá no meu Twitter @marlonhenq.

Flw!

Começando com Verilog

Marlon — Sat, 16 Sep 2023 05:54:14 +0000

Opa, eae?

Demorou, mas chegamos a um dos posts que realmente tinha uma galera me cobrando para fazer… Circuitos e Verilog sem mais delongas vamos para o conteúdo!

Introdução

Se você quer aprender sobre Verilog acredito que já deve ter passado pela criação de circuitos com álgebra booleana no papel ou com ferramentas como Logisim e CircuitVerse (quem sabe até com redstone no Minecraft?).

Caso ainda não tenha estudado sobre circuitos lógicos, você ainda pode continuar lendo este post, porém a criação de bons códigos em HDLs, se dá pelo bom conhecimento de lógica booleana, então recomendo que estude isso primeiro.

Álgebra Booleana (uma breve recordação)

No princípio, um fio.

É isso mesmo, é só um fio. Porém, o importante para nós é o estado dele, também chamado de nível lógico.
O nível lógico em circuitos digitais se dá por um intervalo de tensões e isso pode variar entre circuitos e famílias de portas lógicas, porém sempre vão seguir um padrão como este:

No nosso exemplo, com uma porta da família CMOS temos um intervalo de 5v a 3.5v o qual o circuito interpretará o sinal de entrada como HIGH (Alto), ou nível lógico 1.
Seguindo o mesmo exemplo, entre 1.5v e 0v o circuito interpretará a entrada de sinal como LOW (Baixo), descrito também como nível lógico 0.

PS: O que acontece caso o sinal recebido esteja entre 3.5v e 1.5v? Simplesmente isso não deve ocorrer, sério! Caso for trabalhar com CIs como este em protoboards trate de não enviar valores nesse intervalo. Os Circuitos integrados não são projetados para receber valores nesse gap e no geral, a especificação diz que não se sabe o que pode sair como resultado após entradas duvidosas como estas. Em outras palavras, seu circuito não funcionará adequadamente.

Contudo, por mais que seja importante entender de onde surgem os níveis lógicos, quando estamos trabalhando com circuitos digitais, não nos preocuparemos com a tensão em momento algum, iremos apenas tratar dos estados (Altos(1) e Baixos(0)).

Assim iremos descrever algo como: “esses fios ou as entradas dessa porta, estão com nível lógico Alto ou Baixo”

Portas Lógicas!

Descrevendo de maneira rápida, elas são um amontoado de componentes eletrônicos tendo como principal os transistores.
Possuem N entradas que se unificam em uma só saída, e tem o seu comportamento descrito por tabelas verdade.

Circuitos Lógicos!

A partir do momento que temos portas lógicas podemos agrupá-las em circuitos e solucionar problemas lógicos mais complexos.

Vamos supor um problema:
Você possui um escritório com duas janelas e uma porta, em cada abertura está instalado um sensor que indica quando a mesma está aberta retornando o estado 1 (e 0 quando está fechada).

Quando você está no escritório sempre deixa a porta aberta, e como está dentro do comodo as janelas podem estar em qualquer posição, pois ninguém tentará entrar pela janela enquanto você está por lá.
Porém, você é uma pessoa um pouco esquecida e saiu algumas vezes do seu local de trabalho fechando a porta, porém deixando ao menos uma janela aberta.

Como sabe eletrônica, resolveu colocar um alarme (que reproduz som caso receba 1 em sua entrada e fique ocioso caso receba 0) para que isso não ocorra mais. Assim, caso esteja fechando a porta, contudo ao menos uma das janelas esteja aberta, o alarme soará o fazendo entrar novamente, fechar a(s) janela(s) aberta(s) e por fim sair deixando o local em segurança.

A princípio, para quem ainda está começando com lógica de boole, este problema pode parecer complexo, mas já te adianto que com uma unidade de 3 das portas citada a cima ele pode ser solucionado, vejamos:

Devemos saber quando uma OU outra janela está aberta (ou até ambas), assim podemos unificar o sinal dos dois sensores das janelas na saida de uma por OR.

Bom, agora sabemos quando alguma janela está aberta, caso isso aconteça E a porta esteja fechada devemos acionar o alarme! Assim, caso a saída do nosso OR seja 1 E nossa porta esteja fechada (portanto emitindo o estado 0) temos que ter o sinal 1 para nosso alarme.

Podemos Inverter a saída do sensor da nossa porta, com uma porta NOT, agora quando for fechada temos como resultado 1.

E quando tivermos 1 vindo da nossa porta OR E 1 vindo da nossa porta NOT temos nosso caso de acionamento do alarme, logo um AND entre esses dois sinas pode resolver nosso problema!

E por fim temos nosso circuito! Mesmo com poucas portas conseguimos descrever um problema maior e real!

Lógico, há muitas outras formas de se chegar neste circuito além da dedução, o ideal inclusive é utilizar formar mais elegantes, como a criação de tabelas verdades e a simplificação por mintermos ou maxtermos, quem sabe até a utilização de mapas de karnaugh.
Porém, aqui neste post estou apenas relembrando alguns conceitos de álgebra booleana, o foco aqui será o Verilog.

Linguagens de Descrição de Hardware (HDLs)

Linguagens de Descrição e Hardware são, como o próprio nome já diz, linguagens utilizadas para descrever como são hardwares.
Ok?... Mas o que exatamente é isso?

Quando se está aprendendo sobre eletrônica digital, e assim, desenvolvendo circuitos como o exemplo anterior, é comum desenhar em papéis ou utilizar ferramentas gráficas (como as já citadas Logisim e CircuitVerse), onde pelo “arrasta e solta” de portas lógicas criam-se circuitos maiores.

Para pequenos projetos, essa forma de criação é válida e ajuda muito o entendimento pelo visual. Porém, projetos mais complexos exigiriam folhas e folhas ou ficariam confusos em pequenas telas. Além disso, às vezes necessita-se replicar componentes a exaustão com a instanciação de N módulos, desenhar tudo isso levaria tempo de mais e a replicação por ctrl+c, além de ser deselegante, criaria os mesmos problemas de manutenibilidade de replicação de códigos em programas.

Em resposta a tudo isso, surgem as HDLs, vindo como linguagens próximas em sintaxe as linguagens de programação e tendo como vantagem extra a simulação com testes em computadores e hardwares específicos (FPGAs).

As HDLs ainda podem descrever o hardware pela descrição formal de seus circuitos, isto é, descrever os componentes e portas lógicas os conectando um a um, ou também informar como o circuito deve funcionar e deixar a encargo dos compiladores e interpretadores criarem um circuito para uma resposta equivalente. (Falaremos mais disso em Verilog e suas formas Comportamentais, Estruturais e Funcionais).

HDLs VS Linguagens de Programação

Se tem algo que deve ficar claro aqui e se você tiver que levar apenas um conhecimento deste grande post leve esta informação:
“Linguagens de Descrição de Hardware NÃO são Linguagens de Programação!”.

Elas de fato parecem linguagens de programação, possuem sintaxes parecidas e até copiadas, mas não são!

Por que isso deve ficar claro?
Quando se está aprendendo HDLs e não se associa o pensamento a hardware e circuitos, é muito comum, pela próxima sintaxe, cair no pensamento imperativo de linguagens comuns de programação.

Isto pode fazer você pensar que as portas e módulos ali descritos estão funcionando de maneira sequencial, ou seja, um após o outro conforme estão descritos no arquivo. Porém, isto não acontece na realidade, os módulos ali descritos estão equivalentemente a circuitos fixos em uma protoboard ou PCB, não existe quem é ativado ou está funcionando primeiro (a não ser de circuitos acionados por clock), todos ali estão ao mesmo tempo, funcionando, recebendo suas entradas e acionando suas saídas.

Isto tanto é verdade que, na prática, tanto faz a ordem que as linhas do seu código aparecem, você pode alterá-las mudando de ordem no arquivo e isso não mudará o circuito final feito.

Lembre-se, você apenas está descrevendo uma placa dizendo o que está nela e como estão ligados.

Dito isto, não programamos em Verilog ou em qualquer outra linguagem de descrição de hardware.
Eu sei, isso é triste e decepcionante, mas como não estamos tratando de linguagens de programação, não estamos programando.
O que estamos fazendo, então? Descrevendo!

Quando se está utilizando HDLs você está descrevendo hardware, logo, quando alguém olhar sua tela e o perguntar “O que você está fazendo?”, você já tem a resposta “Eu estou descrevendo hardware!”, aposto que irá impressionar todas as gatinhas e gatões e fazer você ter um excelente encontro depois.

Um adendo: Pela minha lógica, salvo algum equívoco, não podemos programar, mas podemos sim “codar” em HDLs. Veja bem, “codar” vem da nossa forma de abrasileirar “coding” que nada mais é que “codificação”, assim, se estamos fazendo código, não interessa de qual tipo, estamos codificando ou “codando” e como HDLs são códigos, logo, podemos dizer que estamos codando em Verilog ou demais linguagens de descrição de hardware.

Verilog

Chegamos finalmente no Verilog!
Verilog é simplesmente uma das primeiras e acredito que a linguagem de descrição de hardware mais utilizada.

Nela tudo o que fazemos está dentro de módulos, assim o início de um projeto se dá pela instanciação do primeiro módulo, que pode receber qualquer nome, vamos ao código:

module meuModulo(input entrada, output saida);
    assign saida = entrada;
endmodule

Temos inicialmente a palavra reservada module, esta instancia nosso modulo, após ela vem o nome que daremos ao nosso módulo “meuModulo”.
Em seguinte vem, entre parenteses, a listagem das entradas e saídas com as palavras reservadas input e output, e após elas os nomes das portas que damos aos nossos módulos.

No fim temos a palavra reservada endmodule a qual fecha nosso bloco de módulo e ao meio que desenvolveremos a lógica deste.

Como conteúdo do nosso módulo temos apenas uma linha assign entrada = saida;, nela estamos atribuindo a entrada a saída diretamente, pois não estamos fazendo nada com o sinal, ou seja, aqui criamos apenas um fio, tudo que vem pela entrada sai pela saída sem nenhuma lógica adicional.

Representação visual do módulo:

Sintaxe:

-Ligações com Fios, Registradores e Lógicos (Wires, Regs and Logics)

Todos os inputs e outputs dos módulos em Verilog são fios (Wires), além disso, wires auxiliares podem ser declarados dentro de módulos com a sintaxe “wire nome_do_fio;”.

Fios funcionam como fios na vida real, isto é, ligam coisas e o estado que eles representam depende de naquele mesmo momento estarem recebendo este estado.
Um fio só irá “devolver” 1 se no mesmo momento da “consulta” ele estiver recebendo 1 de alguma fonte.

Muito parecido aos fios, registradores também recebem e emitem valores, porém estes guardam os valores recebidos até que recebam um valor diferente, ou seja, se um reg em algum momento receber o estado 1, irá emitir esse estado até que receba 0, caso nunca receba 0 irá emitir para sempre 1.

A sintaxe para descrever um registrador é: “reg nome_do_registrador;”

Verilog recebeu diversas atualizações ao longo do tempo, porém sempre manteve compatibilidade com as versões antigas; por isso, há às vezes, muitas sintaxes e modos de se descrever a mesma coisa.
Uma das grandes atualizações do Verilog e a mais recente é a SystemVerilog, e nela foi introduzido um novo tipo de ligação a Lógica.

Em muitos códigos verilog a diferença prática entre regs e wires passa a ser nula, podendo se usar qualquer um dos dois e tendo como final um circuito que resolve o mesmo problema, além disso, essa diferença acabava por complicar um pouco o desenvolvimento em verilog sobretudo para iniciantes.

Assim, na versão SystemVerilog a ligação lógica foi desenvolvida como uma abstração para substituir ambos (regs e wires) deixando a encargo do interpretador decidir como logic irá se comportar.

A sintaxe para descrever um lógico é: “logic nome_do_registrador;”

-Vetores ou Barramentos (Vectors/Buses)

Até agora tratamos de wires, regs e logics com apenas 1 bit, porém cada um destes podem ser um vetor que representa um barramento de N bits a sintaxe para barramentos será:

O tipo (wire, reg, logic) seguido do tamanho representado pelo último valor do barramento seguido de dois pontos e o primeiro valor (entre colchetes) e o nome do nosso vetor.
Ex: Um vetor de 8 bits do tipo wire será descrito assim:

wire [7:0] vector;

Da mesma forma um vetor de 16 bits do tipo reg será descrito:

reg [15:0] vector;

Também pode-se querer separar apenas um bit ou alguns bits de um vetor, neste caso se utiliza a mesma notação dos colchetes, porém após o nome do vetor, ex:

assign a = vector[2];

Neste exemplo atribui-se a “a” o terceiro bit do vetor.

assign b = vector[4:2];

Neste exemplo atribui-se a “b” os bits da posição 3 a 5 (lembrando que “b” deve ser declarado antes como um vetor de pelo menos 3 bits).

-Operadores Lógicos (Logic Operators)

Operadores lógicos são, como o próprio nome já, diz operadores que exercem funções lógicas, ou nesse caso funções de portas lógicas.
Assim eles irão receber dois bits e retornar a resposta de um bit coerente a ponta lógica que o símbolo representa.

São eles:

Símbolo	Função
&&	And
\|\|	Or
!	Not

Um exemplo utilizando o operador And, seria:

wire a, b;
wire result; 

assign result = a && b;

Aqui o wire, result recebe constantemente o valor resultante da porta AND com as entras “a” e “b”.

-Operadores Bit a Bit (Bitwise Operators)

Operadores bit a bit irão performar em cada bit de um vetor separadamente, ex:

wire [2:0] a, b, result; //Três vetores de 3 bits cada

assign result = a & b;

Aqui atribui-se a operação And dos vetores “a” e “b” bit a bit no resultado. Este código seria equivalente a:


wire [2:0] a, b, result; //Três vetores de 3 bits cada

assign result[0] = a[0] & b[0];
assign result[1] = a[1] & b[1];
assign result[2] = a[2] & b[2];

Onde cada bit é atribuído individualmente.

Tabela de operadores bit a bit:

Símbolo	Função
&	And
\|	Or
~	Not
^	Xor

Operadores bit a bit ainda podem se comportar como operadores de redução de vetores, isso acontece caso sejam colocados juntos a um único vetor, realizando assim a operação do símbolo com todos os valores deste barramento, retornando um único bit resultado dessa operação. Ex:


wire [2:0] a;
wire result; 

assign result = &a;

Este código seria equivalente a:

wire [2:0] a;
wire result; 

assign result = a[0] & a[1] & a[2];

Obs: Operadores bit a bit podem ser usados com wires, regs e lógicos de um único bit (não vetores), e irão performar igual a operadores lógicos, porém isso não é considerado uma boa prática.

-Operadores Aritméticos (Arithmetic Operators)

Operadores aritméticos, são os mais parecidos com linguagens de programação, eles podem ser utilizados para bits únicos, porém são bem mais comuns serem utilizados junto a vetores, a tabela que os representa é:

Símbolo	Função
+	Adição
-	Subtração
*	Multiplicação
/	Divisão
%	Mod (Resto da divisão)
**	Exponenciação

Um código que representa a soma binária é:

assign result = a + b;

Atenção: Nestas operações, para o bom funcionamento, deve-se ficar atento ao tamanho dos vetores que recebem o valor da operação, visto que estes devem conseguir comportar o valor resultante da operação. Caso o vetor de destino tenha menos bits que o valor resultante, os bits mais significativos serão perdidos, podendo comprometer o bom funcionamento.

-Representação numérica

Verilog pode automaticamente converter números em diferentes bases para realizar comparações ou atribuições a notação para isso é:
O tamanho necessário para armazenar o número em binário, seguido de aspas simples, uma letra reservada para representar em que base está escrita o número (d = decimal, h = hexadecimal, b = binário, o = octal) e o número propriamente dito. Ex:

Atribuindo a um vetor o número 12 em decimal:

assign vector = 4'd12;

Atribuindo a um vetor o número 1F em hexadecimal:

assign vector = 8'h1f;

Atenção: Assim como nas operações aritméticas, o vetor de destino precisa conter o número suficiente de bits para representar corretamente o número atribuído, caso isso não ocorra os bits mais significativos serão perdidos podendo comprometer a boa lógica do se circuito.

-Concatenação e Replicação

Ainda na manipulação de vetores tem-se a concatenação e replicação.
A concatenação se dá por juntar bits e/ou vetores, ex:

assign vector0 = {a, c}; //Concatenação de “a” e “c” (podem representar vetores ou bits únicos)

assign vector1 = {a, b, 2'b10, d}; // Concatenação de “a”, “b”, 10 (em binário) e “d”

assign vector2 = {a[2], b, c, d[3:1]}; // Concatenação do bit na segunda posição de “a”, “b”, “c” e do intervalo de bits desde a posição 3 até a posição 1 do vetor “d”

Aqui atribuímos aos vetores diferentes concatenações que utilizam bits, outros vetores ou partes de outros vetores.

A replicação possuí uma sintaxe muito parecida a concatenação, coloca-se quantas vezes irá se repetir o valor seguida do valor entre chaves. Ex:

assign vector0 = 10{1'b1}; //10 bits “1” seguidos

assign vector1  = 12{2'b10}; //12 vezes a replicação dos bits “10”

assign vector2 = 6{a[15]}; //6 vezes o bit da posição 15 do vetor “a”

Concatenações e replicações muitas vezes são utilizadas juntas:

assign vector = {a[15], 15{1'b0}}; //Bit da posição 15 do vetor a seguido de 15 zeros

-Verilog Estrutural e Funcional

As formas Estrutual e Funcional de Verilog muitas vezes são descritas apenas como Funcional, isso vai variar de autores e sites, por isso irei explicar as duas separadamente e caso você queira, pode entende-las como uma só.

Verilog Funcional:

Para todo efeito, é o verilog que estamos usando até agora, dentro dos módulos para representar as portas e circuitos utilizamos atribuições (assign), seguidas de operadores que criam a lógica do nosso circuito, um exemplo do nosso circuito das janelas e portas descrito no começo desse post é:

module acionaAlarme(
input janela0,
input janela1,
input porta0,
output saida
);

    assign saida = (!porta0) && (janela0 || janela1);

endmodule

Obs: Os parenteses são usados para definir quais ligações devem acontecer primeiro (assim como em qual conta deve preceder em linguagens de programação).

Verilog Estrutural:

O verilog Estrutural cria sua lógica chamando portas como módulos.
A sintaxe padrão é: o nome da porta e entre parenteses seu output (sempre em primeiro) e seus inputs logo após (separados por virgulas).
Ex:

and (output, inut1, input2);
not (output, input1);

E um código equivalente ao apresentado anteriormente seria:

module acionaAlarme1(
input janela0,
input janela1,
input porta0,
output saida
);

    wire portaN, janelas;

    not (portaN, porta0);
    or (janelas, janela0, janela1);
    and (saida, portaN, janelas);

endmodule

Verilog Comportamental:

Não estamos trando de Elixir, mas de fato é aqui que a mágica e alquimia acontece.

Até agora descrevemos o circuito como ele é, ou seja, quais portas deve utilizar, quais segmentos de vetores deve utilizar, como estão as ligações ente módulos e etc.

No verilog comportamental não faremos isso, e sim descreveremos como o circuito deve se comportar, a criação do circuito fisicamente com as portas lógicas será dada pelo interpretador.

Aqui a criação de códigos Verilog se torna muito mais próxima da criação de códigos em linguagens de programação, porém volto a lembrar, por mais que você efetivamente não esteja fazendo o circuito o interpretador estará, e tudo que você cria representa um circuito em uma placa e não um código em uma máquina.

A tag que marca os módulos comportamentais é a tag “always” que normalmente será sucessida de um “@” (at) e alguma entrada, como clock do circuito em circuitos com clock, alguma saida de outro módulo, ou até mesmo “*” que representa qualquer mudança possível em qualquer lugar do circuito.
A entrada do always irá ditar quando este bloco é executado.

Dentro da tag always, pode-se usar comparações com ifs ou cases ou atribuições que só ocorrem caso a entrada do always seja confirmada.

O código equivalente a os dois já apresentados aqui, porém no modelo Comportamental é:

module acionaAlarme2(
input janela0,
input janela1,
input porta0,
output saida
);

    always @(*) begin
        if (porta0 == 1'b0 && (janela0 || janela1)) begin
            saida = 1'b1;
        end else begin
            saida = 1'b0;
        end
    end

endmodule

O modelo comportamental é de fato uma linguagem a parte e é bastante complexo, sua utilização é muito comum em circuitos com armazenamento (flip-flops) como as máquinas de estado.
Irei deixar apenas a introdução desse tipo de módulos nesse post, podendo futaramente abordar mais sobre ele em publicações futuras.

Ferramentas

Para quem está começando acredito que a melhor forma de aprender é se deparar e se submeter à problemas, para isso o site HDLBits é ótimo!
Para quem é de programação já deve ter visto sites de desafios como Exercism ou o Beecrowd (antigo URI Jungle), o HDLBits é a versão deles para hardware e verilog, lá há vários exercícios, os quais você submete sua resposta e ela é avaliada por testes para indicar o bom funcionamento.

Caso precisem de ajuda eu tenho esse repositório com resoluções de boa parte dos exercicios do site em: https://github.com/MarlonHenq/Verilog-HDLBits-solutions

Outra forma muito bacana de aprender Verilog e de visualizar seus códigos é utilizar o DigitalJs que possui sua versão online no site e também é uma extensão no VSCode, todas as imagens dos circuitos deste post foram feitos com essa ferramenta.

Isso é tudo!

Ufa! Esse post demorou muito para ser feito e foi muito complexo, mas espero que você tenha gostado e aprendido muito!
Caso reste dúvidas deixe ai embaixo (para o pessoal do Dev.To) ou me chamem no twitter @MarlonHenq.
Me sigam lá para demais atualizações e posts e caso esse post tenha te ajudado não deixe de compartilhar nas suas redes.

Flw!

Hey Saiu a continuação deste post

Confira em: https://dev.to/marlonhenq/comecando-com-verilog-2-instanciacao-de-modulos-1mno

Criando web scrapers de maneira rápida com Beautiful Soup

Marlon — Tue, 22 Aug 2023 15:26:18 +0000

Opa, eae?

Recentemente tive que fazer um web scrapper simples (de preferência rápido) e me deparei com antigas tecnologias de raspagem de dados que já usei como Selenium e Scrapy e bom… Eles não são muito simples.

Se você já usou o Selenium sabe da dificuldade e da não praticidade de ter que instalar webdrivers, depois ter o seu bot rodando em um navegador não é nada muito elegante, muito menos performático.
Scrapy é de fato uma excelente ferramenta muito robusta para web scraping, porém ela não é muito prática, basta ver quantos arquivos ela gera para, nesse caso, um bot extremamente simples.

E foi ai que eu acabei me deparando com o Beautiful Soup.

Beautiful Soup

Beautiful Soup é uma biblioteca de Python para análise de documentos HTML e XML. O que ele faz é transformar o conteúdo do arquivo em uma árvore de ficheiros, assim fica mais fácil por meio dos métodos da própria lib pesquisar e modificar trechos do código HTML.

Para usarmos essa lib precisamos do nosso gerenciador de pacotes do Python o Pip e rodar o seguinte comando no terminal mais próximo:

pip install beautifulsoup4

E é isso! Nada de projetos pré-prontos gigantes e com 300 arquivos. Bora codar!

Extraindo dados do Quotes to Scrape

Para quem não sabe o “Quotes to Scrape” é um site de citações de pessoas famosas feito justamente para treinar scraping. Ele não apresenta de fato grandes desafios que podem acontecer no trabalho de raspagem de sites mais complexos e que talvez que até tentem impedir automatizações, mas serve como um treino inicial para começar nesse mundo.

O objetivo aqui será vasculhar todas as páginas (10 no total) e procurar todas as citações a Albert Einstein.
Não irei fazer suspense, então segue o código:

from bs4 import BeautifulSoup
import requests

# URL of the page we want to scrape
url = "https://quotes.toscrape.com/page/"

initial_page = 1;
end_page = 10;

author = "Albert Einstein"

quotes = []

# Loop through the pages
for page in range(initial_page, end_page):

    # Get the HTML content
    response = requests.get(url + str(page))

    # Create a BeautifulSoup object
    soup = BeautifulSoup(response.text, "html.parser")

    # Get the quotes
    page_quotes = soup.find_all("div", class_="quote")

    # Verify if the author is in the quote and save it
    for quote in page_quotes:
        if (quote.find("small", class_="author").text == author):
            quote_text = quote.find("span", class_="text").text

            quotes.append(quote_text)
            print("Quote found: " + quote_text)


print("Number of quotes: " + str(len(quotes)))

Link para o código no GitHub: https://github.com/MarlonHenq/Web-Scraping-Quotes-to-Scrape-Beautiful-Soup

Extremamente simples, né? (ainda mais com um comentário a cada linha hahah)

Mas vamos de alguns pontos:

Bom, o BS não pega as informações da página diretamente da web, então a gente chama também a lib “requests” para poder pegar o conteúdo em texto do HTML da página por meio do requests.get().

Dado o código da página a gente faz a nossa sopa com BeautifulSoup(response.text, “html.parser”).

Aí é só aplicar os filtros! Selecionamos todos os quotes com soup.find_all(“div”, class_=”quote”). Marlon, como eu sei qual tag e classe devo pegar? Basta olhar o código dá página, inspecione o elemento de um quote com botão direito do mouse e tenha isso:

Possuindo todas as citações de uma página verificamos se o autor é o nosso querido cientista de língua para fora (Novamente basta olhar as tags e classes no código da página com o inspecionar elemento), e caso for salvamos na nossa lista de quotes e escrevemos a mensagem na tela.

Bingo! Temos todas as frases de Einstein na tela!

Isso é tudo!

Post extremamente simples, de uma ferramenta muito útil no seu dia a dia.

Caso queira outro exemplo, tenho o código que me inspirou a fazer esse post, um raspador do ranking do HDLBits disponível em: https://github.com/MarlonHenq/Web-Scraping-HDLBits-profiles

Se gostou, não se esqueça de me seguir lá no Twitter para receber mais posts: @MarlonHenq
Aproveita e me responde lá se sopa é ou não janta.

Vou indo que minha sopa já está pronta!

Este post foi originalmente postando em: blog.marlonhenq.dev - Dia 29-06-2023

Git e GitHub: O que são e qual a diferença

Marlon — Tue, 22 Aug 2023 15:19:01 +0000

Opa, eae?

Se você está entrando na área de tecnologia com certeza já ouviu esses dois termos e já viu alguém ou até mesmo você já confundiu os dois e é esse o objetivo desse post, elucidar os conceitos e de quebra aprender a usar um pouco.
Porém, já aviso: esse post, por mais que utilize alguns comandos, não tem a pretensão de ser um tutorial de Git, caso você queria algo assim sugiro que consulte o Git4noobs ou a documentação.
Aqui focaremos no que são, o motivo de serem criados e para que usamos.

Git

O Git é uma ferramenta de versionamento de código (na verdade, qualquer tipo de arquivo de texto basicamente), mas o que é uma ferramenta de versionamento?
Quando você criou algum projeto seja ele texto, edição de vídeo, imagem ou código, já deve ter criado versões dele e acabou com uma pasta cheia de cópias como “certo-sem-capa.docx”, “terminado.docx”, “finalEnviar.docx”, “agoraSimFinal.docx”, “ENVIARRRR.docx”?

Eu diria que a maioria já fez algo parecido e nisso temos alguns problemas:
- Não sabemos qual realmente é o arquivo de projeto final, se alguns meses se passarem nem você que criou muito provavelmente vai saber.
- Não sabemos também qual foi a evolução, ou seja, qual arquivo fomos modificando para chegar em outro arquivo.
- No caso específico de texto (e código, claro), também é bem provável que já tenha escrito um parágrafo ou função, tenha apagado e em outro dia tenha percebido que não deveria, ai o único jeito é escrever de novo.
- Cada nova “versão” do seu projeto requer uma cópia do arquivo original com as partes que não foram modificadas e também as que foram inseridas, removidas ou modificadas, ou seja, você passa a guardar dados em redundância consumindo mais espaço que o necessário. Em um arquivo isso pode até ser desprezível considerando o custo baixo de armazenamento de hoje, mas em grandes repositórios de projetos isso pode representar uma boa perda de espaço.

Como resolver tudo isso? Git! Git, meus amigos!

E como o Git resolve isso?

A partir do momento que você já tem o git instalado no seu computador para iniciar um novo projeto basta estar na pasta/diretório e utilizar o ‘git init’.
Assim você acaba de criar um repositório Git no seu projeto. A princípio, nada ocorre, mas para os olhos mais atentos foi criado a pasta (diretório) ".git" (por padrão no linux pastas/repositórios ou arquivos iniciados com ‘.’ (ponto) são ocultos, assim para ver deve-se habilitar a visualização de arquivos ocultos no seu gerenciador de arquivos).

Você NUNCA deve mexer na “.git” caso não queira problemas, estou falando aqui mais para critério de curiosidade de onde ficam as configurações do seu repositório e as alterações commitadas do seu código. É importante saber da “.git” também caso queira copiar os arquivos para outro lugar e também queira levar o git com suas configurações de projeto e commits junto (apesar de termos formas mais elegantes de fazer uma cópia pelo git).

ps. Explicarei o que é ‘commit’ logo.

Tendo um repositório git, o próximo comando será para adicionar os seus arquivos de código nele, para isso vamos digitar o ‘*git add * *’ (git add pode receber nomes de arquivos ou os parâmetros ‘*’, ou ‘.’ para adicionar todos os arquivos possíveis presentes no diretório).

O ‘git add’ apenas lista e mostra os arquivos que receberam alterações foram adicionados ou removidos adicionando tudo isso em um local separado (chamamos esse local de “Área de staging” e você pode ver essas modificações utilizando ‘git status’), mas ainda nada foi ‘salvo’, para isso devemos usar o "git commit -m “Comentário do seu commit”".
E Pronto, o que basicamente acabou de ser feito foi uma imagem do seu repositório atual com todos os arquivos que estão presentes nele, a partir de agora quaisquer modificações que forem feitas adicionadas pelo ‘git add’ e commitadas pelo ‘git commit’ serão salvas também no seu repositório git.

Massa Marlon! Mas o que realmente acabou de ser feito?

Bora lá, quando você iniciou seu repositório pelo "git init" e após isso commitou sua primeira alteração o git salvou o primeiro estado dos seus arquivos, por exemplo:

Aqui tenho uma pasta com dois arquivos o “code.lua” e o “comentarios.txt”.

O conteúdo de “code.lua” é:

O conteúdo de “comentarios.txt” é:

Ainda não temos nenhum repositório Git criado aqui então bora lá:

Após um repositório vazio criado precisamos adicionar nossos arquivos:

Arquivos adicionados à área de staging, agora falta só commitar:

Beleza! Primeiro commit feito, mas eai?

Vamos modificar um arquivo (code.lua) para poder testar um pouco mais:

E agora vamos commitar essas mudanças:

Tudo salvo, se dermos um ‘git log’ podemos ver nossos commits aqui.

Blz, mas como eu posso ver essas modificações?
Com o ‘git diff’ podemos fazer a diferença entre dois commits e ver a evolução do código:

Pronto! Percebemos agora que todas as alterações que fazemos e commitamos ficam salvas e podem ser consultadas posteriormente, inclusive caso você queira desfazer as alterações você pode voltar a commits anteriores por meio do ‘git reset’.
Porém, acho que já joguei comandos demais para você e como o objetivo desse post não é ser um tutorial de como usar Git e sim entender como ele funciona e como usamos deixarei o resto com a documentação e o Git4noobs.

Branches (ramificações)

Todas as alterações salvas que fizemos até agora (os commits) estão localizadas em uma ramificação/branch.
A branch principal do git por padrão é chamada de “master”, também em alguns lugares e repositórios mais novos ela pode ser chamada de “main”, isso acontece pelo histórico não muito legal da palavra “master” e o que ela pode significar em outros contextos.
Inclusive caso você queria mudar o nome da sua branch utilize git branch -m “novo nome”, isso é muito comum de ser feito.

A utilização de branches serve para organizar melhor o seu repositório. Você pode, por exemplo, identificar um bug e perceber que terá que realizar vários commits para arrumá-lo, assim você cria uma branch especial com outro nome só para resolver o bug e quando estiver tudo certo realiza o ‘merg’ (de fundir mesmo), ou seja, taca as alterações que corrigem esse bug para a sua branch de origem.

Branches também são muito usadas para trabalhar em conjunto!
Até aqui só falamos de repositórios locais, mas a maioria dos repositórios locais estão relacionados a algum repositório armazenado em algum servidor, justamente para servir a várias pessoas. Dessa forma, você e seu amigo podem, ao mesmo tempo, modificar partes do código, cada um em sua branch, ao final cada um funde seu código à ‘main’ e o projeto está pronto (parece muito mais elegante que trocar arquivos por drive, né?).

Diferentes branches também são bastante utilizadas hoje, pois as branches main/master (ou qualquer outro nome da branch principal do repositório) estão muito relacionadas ao deploy. Ou seja, em alguns projetos tudo que vai a branch principal vai automaticamente ao servidor em produção, assim fica meio óbvio perceber que não é bom codar diretamente nessas branches, pois qualquer alteração será automaticamente uma atualização na aplicação.
Traduzindo em miúdos, qualquer erro commitado na main vai derrubar a sua aplicação nesse tipo de repositório, logo é bom desenvolver e testar em outra ramificação.

GitHub

Chegamos nele! O tal do GitHub!

O GitHub é, de maneira simples, o maior host de repositórios Git do mundo. Quando falei que a maioria dos repositórios locais estão relacionados a algum repositório em algum servidor, geralmente estão no GitHub. E de quebra o GitHub dá uma interface amigável para visualizar, mergear’ branches, administrar acessos a repositórios e deixar público repositórios Git abertos. Grandes projetos open source estão publicados e são mantidos por lá.

O GitHub se descreve, e de certa forma é mesmo, uma rede social. Lá você tem o seu perfil, pode deixar alguns repositórios seus abertos como uma forma de mostrar o seu trabalho, ainda pode seguir pessoas e dar estrelas (basicamente likes) em seus repositórios.

Vale lembrar que como o GitHub ainda existem outros serviços como Bitbucket e GitLab, que basicamente são concorrentes diretos.

Diferença entre Git e Github

Se você leu esse post até aqui, primeiro, obrigado! Mas espero que você entenda que querer falar de diferença entre Git e GitHub não faz sentido, a pergunta “Qual a diferença entre Git e GitHub?” não faz sentido.
Isso acontece porque eles não são nem conceitos iguais, nem diferentes, o Git se propõe a ser um software de versionamento com a possibilidade de conectar repositórios locais a remotos. Partindo dessa ideia o GitHub vem como uma rede social onde se hospeda repositórios Git podendo facilitar a disponibilidade de código e compartilhamento de projetos. O conceito do GitHub depende da existência do Git, mas não tem como compará-los, pois eles nem possuem o mesmo propósito.

Existe uma piada de que quando se pergunta “Qual a diferença entre Git e GitHub?” a resposta sempre é “É a mesma que a do Porn e do PornHub” e o maior problema é que realmente é uma boa comparação! Do mesmo jeito que existem repositórios Git, existem vídeos pornôs e do mesmo jeito que você pode compartilhar seu repositório online no GitHub, bom, existe o PornHub para o outro lado também kkkkk
Eu não sei se precisava explicar isso para você com esse nível de detalhamento, porém acredito que agora fica fácil de entender...

Bom, isso é tudo pessoal!

Meu documento de texto aqui já está na sétima página isso que ele nem possui as imagens que serão adicionadas no post final que você acabou de ler.

Espero que tenha aprendido e entendido um pouco mais sobre essas tecnologias aqui, para saber de novos posts me siga lá no Twitter: @MarlonHenq

Obrigado por ter lido!

Flw!

Este post foi originalmente postando em: blog.marlonhenq.dev - Dia 29-05-2023

Plataformas e Tecnologias Gratuitas para Estudantes

Marlon — Tue, 22 Aug 2023 15:06:27 +0000

Opa eae!?

Se vocês pensam que nós fomos embora, nós enganamos vocês, fingimos que fomos e voltamos, Ói nós aqui outra vez!

Eu sei, eu sei… Disse que iria postar aqui todos os meses e o resultado foi mais de um ano em hiato. Porém, estou de volta aqui para falar sobre ferramentas gratuitas que você pode ter sendo um estudante de faculdades de tecnologias (e até outros cursos também).

Vamos lá!

JetBrains

Se você está no mundo de tecnologia há algum tempo já deve ter ouvido o nome da JetBrains, mas caso ainda não saiba ela é a empresa responsável por muitos softwares de desenvolvimento (as famosas IDEs) amplamente utilizados como PHPStorm, PyCharm, DataGrip, IntelliJ IDEA e etc.

O legal disso tudo é que a maioria dos softwares estão disponíveis gratuitamente pelo pacote de estudantes e você pode fazer o seu cadastro em: https://www.jetbrains.com/community/education/

AutoDesk

Famosa entre os engenheiros principalmente pelo AutoCad a AutoDesk também é uma gigante dos softwares de engenharia e design.

Mais especificamente para o pessoal de TI eu indico o Eagle e o Fusion 360 (que são os que eu mais usei). Sendo o primeiro um software de criação de circuitos e PCBs e o segundo um software de modelagem 3D para desde simulações de tensão de carga até a criação de peças para impressões 3D.

O interessante ainda desses dois programas é que ambos possuem integrações, sendo possível a criação de uma PCB no Eagle que é posteriormente exportada para dentro de uma case em 3D no Fusion. Assim pode-se criar um produto final completo apenas com esses dois softwares.

Da mesma forma que a JetBrains o cadastro de estudante é bem simples e pode ser feito por esse link: https://www.autodesk.com.br/education/edu-software/overview?sorting=featured&filters=individual

GitHub Pro, GitHub Student Developer Pack e GitHub Copilot

Eu ainda falarei muito mais sobre versionamento, Git e GitHub nesse blog (e provavelmente em outras redes sociais minhas), mas se você está minimamente inserido no mundo de TI já deve ter ouvido falar sobre a plataforma que é o GitHub e sabe que ela é bastante importante para a comunidade de tecnologia.

Então, saiba que você pode ter a conta Pro, a inteligência artificial ajudante de escrita de códigos (Copilot) e a todo um programa que te dá acesso a outros softwares e plataformas importantes no mundo de tecnologia (Student Developer Pack) de graça sendo um estudante.

Sobre o Student Developer Pack eu ainda destaco duas plataformas que é a Termius, um software que eu utilizo bastante para acessar servidores remotamente por SSH e a DataDog, uma plataforma de análise e monitoramento de servidores, bancos de dados e serviços muito utilizada no mercado.

Para realizar sua inscrição basta ir para esse link: https://education.github.com/pack

Isso é tudo, pessoal

O objetivo desse post é ser rápido mesmo e apresentar softwares que eu pessoalmente acabo utilizando no meu dia-a-dia graças a eu ser um estudante de faculdade de tecnologia.
Obviamente existem muitas outras plataformas com vantagens para discentes (e até docentes) e quem sabe eu não acabe fazendo uma versão 2 desse post, mas por hoje é isso, em breve devo voltar com mais conteúdos para esse blog.

Não se esqueçam de me seguir no Twitter para receberem notificações de novas postagens: @marlonhenq
E para demais redes sociais e contatos mais profissionais chequem o meu site: MarlonHenq.dev

Flw!

Este post foi originalmente postado em: blog.marlonhenq.dev - Dia 21-05-2023

Manual de Sobrevivência na Campus Party 14

Marlon — Tue, 22 Aug 2023 15:01:06 +0000

OOOooooOOOOoooOOOo!!!

Eae? Vai para Campus Party? É a sua primeira vez? Então, cola aqui que eu vou te explicar tudo (ou quase tudo) do evento!

Cheguei! E agora?

Se você acabou de chegar no Anhembi prepare-se: você vai pegar filas. Sim, no plural!
E se tem uma coisa que o campuseiro gosta é de fila, entramos em filas até sem saber onde elas vão dar, então já pode ir se acostumando…

Mas a primeira fila que você deve pegar é a do credenciamento, nela você deve apresentar todos os documentos necessários (que estão listados no Guia do Campuseiro) para te identificarem e te darem a sua credencial.

Pegando a sua credencial coloque logo no pescoço já que o uso dela dentro do evento é obrigatório e ela que será usada para te identificar quando você sai e entra do pavilhão e da área de camping.

Próximoooooo!

Agora vamos para mais filas!!!
Caso você vai acampar (o que eu recomendo para ter a experiência mais completa), direcione-se para a fila da primeira entrada do evento. Essa é de fato a mais demorada, pois a Staff estará revistando o que o pessoal anda levando para o local (no geral vão passar suas malas no raio-x e só abrir se acharem algo meio estranho, mas já aconteceu de um dos raio-x queimar nessa hora e terem que revistar boa parte das bagagens).

Falando em revistas fica aí um aviso: É proibida a entrada com bebidas alcoólicas no evento!! Porém, vou falar um pouco mais disso futuramente nesse mesmo post…

Entrei!!

Estando finalmente dentro do Anhembi você possui basicamente duas escolhas e a ordem não muda muito, mas irei dizer na que prefiro.

Primeiro, bora guardar essas tralhas na barraca?!
Para encontrar a sua barraca basta ver o seu crachá que terá escrito em algum lugar algo como “E11” ou “H21”, esse é o endereço da sua barraca e basta andar um pouco até encontrar ela fisicamente (quase que em uma batalha naval seguindo as letras e números).

Já que estamos falando da barraca, vamos de umas dicas:

Leve um cadeado para unir os zíperes de sua barraca trancando-a e deixando suas coisas em segurança.
A barraca é sua (isso mesmo) e no final do evento, se quiser, pode desmontar e levar para casa.
Para ter boas noites lembre-se de levar algo para deitar (saco de dormir, colchão inflável, colchonete e etc), algo para apoiar sua cabeça (travesseiro inflável, almofada ou até um travesseiro mesmo) e, caso tenha espaço e achar necessário, algo para se cobrir (assim como outros itens como um lençol para o seu colchão).

Após ter arrumado a sua barraca já deixando pronta para tirar aquela soneca (se for encher colchão, faça relativamente cedo, você não que acordar o coleguinha do lado com o barulho da bomba de encher, né?), bora para a segunda coisa!

Vamos de mais filas! Eba!! Porém, essa é a última.

(Editor do futuro veio para avisar: Essa definitivamente não será a última. Ame as filas!)

Pegue o se PC ou notebook para a fila de Cadastro de Equipamento, nela seu equipamento principal será cadastrado e receberá uma etiqueta para ficar vinculado a você.
Detalhe: Só PCs e Notebooks são cadastrados. Celulares, tablets, consoles e periféricos mesmo muitas vezes sendo mais caros que computadores não são. Cuide bem deles!

Setup!

Tudo pronto para pegar seu computador escolher um lugar nas mesas e montar o seu setup, logo, vamos de mais dicas:

Você tem direito a um cabo de rede com acesso à internet e uma tomada na mesa, assim, para ligar mais equipamentos, considere levar um filtro de linha e no caso da rede um switch e cabos.
Não há Wi-Fi.
O que a maioria dos campuseiros faz é levar o seu roteador para criar suas redes privadas, o problema é que se acaba tendo um ‘flood’ de sinal e assim todas as conexões wireless acabam ficando lentas. Então, se puder, junte seus amigos em uma mesa só para compartilharem o mesmo sinal.
Não entre em redes que você não sabe de quem são!
Por mais que a Campus seja um ambiente bem seguro, estamos falando de uma galera que manja e ama brincar com tecnologia e de ser o ‘hackerman’, portanto, NÃO entre em qualquer rede aberta (inclusive isso é uma dica para vida).
Falando em ambiente seguro… Sim, nós deixamos os computadores em cima das mesas e saímos, vamos dormir, vemos palestras, vamos comer e etc. E no geral não há casos de furtos no evento (se quiser é só pesquisar), contudo, mesmo assim, é sempre recomendado cuidar bem de suas coisas.
Se o seu notebook (computador e/ou monitores) possuem a “K-Slot” ou “kensington lock” (uma entrada geralmente com um cadeado desenhado ao lado) é possível usar uma tranca de computador (encontra-se facilmente a venda na internet) para prende-lo na mesa ou até em outras coisas.
Caso esteja indo com amigos busquem revezar quem fica na mesa cuidando dos equipamentos.

Palcos!

A Campus Party conta com palcos com temas diferentes e palestras diversas durante todo o dia, então, vale ficar ligado no cronograma de palestras que deve ser liberado em breve no site do evento para marcar as que quer ir.

Após o horário que se encerram as palestras, os palcos, no geral, ficam livres para as pessoas se reunirem, assim não se espante de ver, por exemplo, às duas da manhã uma roda de violão ou conversas diversas rolando nos palcos, se quiser, não hesite em participar aposto que irão te receber bem.

Comida!

Há algumas opções para se alimentar:

Pacote alimentação (Catering): Irá oferecer as 3 refeições diárias na maioria dos dias de evento (com a exceção do dia de entrada que geralmente não há café, afinal o credenciamento, no geral, começa ao meio-dia e no dia de saída que não terá a janta e talvez o almoço dependendo dos horários), nas edições que já fui optei por ele e a comida era muito boa, além de ser à vontade no almoço e janta. O café da manhã é um pouco mais limitado, porém mais que o suficiente (na minha opinião) sendo uma sacolinha com pãezinhos recheados com queijo, alguma fruta e um bolinho, o leite e/ou café são à vontade.

A desvantagem é que o preço do catering é um pouco salgado.

Obs: No momento que estou escrevendo esse post segundo a organização do evento “o Catering está em processo de negociação com os fornecedores”.

Ainda no evento pode-se encontrar alguns quiosques com lanches (Obs: os preços também devem ser um pouco caros).
O que muitos campuseiros fazem, além de levar snacks, é ir para fora do pavilhão pedir delivery ou encontrar com os vendedores que, sabendo anteriormente do evento, já vão preparados com marmitas, pizzas e lanches para vender na porta.

Campus B

Falando em sair do evento, aos arredores da Campus sobretudo de noite, acontece o que chamamos de Campus B. O que ocorre é que basicamente os campuseiros se juntam para trocar uma conversa mais descontraída e comer uma pizza dos vendedores que citei anteriormente.

Lembra das bebidas? Sendo proibidas dentro do evento, o pessoal aproveita para comprar e tomar ali fora mesmo (com moderação hein).

Open Campus

Além da Campus B, temos a Open Campus, só que essa é oficial do evento e conta com diferentes atrações: Simuladores de voos e corrida, batalha de robôs, corridas de drones e etc.

Vale lembrar que a Open Campus tem esse nome por ser aberta para todo o público e não só aos Campuseiros. Se você for de São Paulo e quiser dar uma passada lá é só colar!

Cultura da Campus!

Um campuseiro sem cultura é um campuseiro sem história (ou sem filas)...

Você acha que juntando um monte de nerds no mesmo lugar não iriam sair memes, piadas e até alguns “rituais tribalistas”?
É isso mesmo que acontece, e bora ficar por dentro de alguns dos clássicos!

OOooooOOOoooOOOooo!! (Não, eu não esbarrei no teclado ou deixei meu gato pisar nele).
O “OoooOOoooOOO!” é a forma em texto de representar “O grito de guerra dos campuseiros”, acontece mais ou menos assim:
Alguém, de repente grita “oooOOooooOOoo!” em seguida todo o resto do evento faz o mesmo. Não precisa de um motivo ao certo, apenas acontece, esteja preparado e não esqueça de gritar em alto e bom som!

Próximo!!
Quase como uma derivação do primeiro o “Próximo” passa a ser o nosso grito de guerra durante as filas (e são muitas). Também não há um motivo, basta alguém virar para você gritando “próximo” assim, vire-se para trás e chame o próximo desencadeando um efeito dominó.

Corrida das Cadeiras
Quando eu disse “rituais tribalistas” eu não estava exagerando. A Corrida das Cadeiras consiste em basicamente alguém (como sempre sem nenhum motivo) pegar uma cadeira, segura-la em cima da cabeça e sair correndo pelo recinto inteiro desencadeando uma onda de outras pessoas pegando suas cadeiras e correndo.
Obs: Muitas vezes fazendo barulhos neandertais tais como “Uga! Uga!” ou apenas gritando “Vem pra cadeira” para convocar mais pessoas para a corrida.

Links Extras

A Campus Party é gigante e definitivamente eu poderia escrever mais páginas e páginas sobre o evento e ainda não conseguir passar todos os detalhes.

Assim, resolvi deixar outros conteúdos aqui para vocês:

Guia do campuseiro oficial: https://brasil.campus-party.org/guia-do-campuseiro/

Pastebin - Dicas para campus - By: @DevMozao: https://pastebin.com/j3WJABh1

Vídeo - Como se Preparar Para a Campus Party - By: @DevMozao: https://www.youtube.com/watch?v=PMxfkTp1xw4

Fim!

Muito obrigado por ter lido esse post até o final, caso ele tenha te ajudado considere compartilha-lo com outros futuros (ou de longa data) campuseiros.

Também não esqueça de me seguir no Twitter @MarlonHenq, onde avisarei de novos posts.
Caso ainda tenha alguma dúvida sobre a Campus pode me perguntar pelo Twitter também (tanto me marcando, tanto pela DM).

Flw! Nos vemos na Campus Party 14!

Este artigo foi originalmente postando em: blog.marlonhenq.dev - Dia 24-01-2022