Arduino - Sketch : Contador com display LCD 16X 2 e monitor serial

 

 

Imagem - Circuito no simulador Proteus 

 

 

//Programa: Display LCD 16 x 2 / contador
//Autor: Anderson O. de Sampaio
 
//Carrega a biblioteca LiquidCrystal
#include <LiquidCrystal.h>
#include <Wire.h>


//Define os pinos que serão utilizados para ligação ao display
LiquidCrystal lcd(22,23, 24, 25, 26, 27);

//LiquidCrystal lcd(22,23, 24, 35, 47, 46);

int pino_sensor = 30;
int valor = 1; //Variavel leitura sensor
int contador = 0;
 
void setup()
{
  Serial.begin(9600);

  pinMode ( pino_sensor, INPUT);
 
  //Inicializa o display LCD 16x2 I2C
  lcd.begin(16, 2);
  //informacoes iniciais
  lcd.setCursor(0, 0);
  lcd.print("Sensor Sw");
  lcd.setCursor(0, 1);
  lcd.print("Contador: 0");
  Serial.println("Contador com sensor chave");
}
 
void loop()
{

  valor = digitalRead(pino_sensor);
  if (valor == 0)
  {

    // Incrementa contador
    contador++;
     //Mostra o valor do contador no display
    lcd.setCursor(10, 1);
    lcd.print(contador);
    //Mostra o valor do contador no serial monitor
    Serial.print("Contador: ");
    Serial.println(contador);
    //Loop caso o objeto fique parado em frente ao sensor
    while (digitalRead(pino_sensor) == 0)
    {
      delay(100);
    }
  }
}

Read More

Arduino - Display LCD 16×2

 O display LCD 16×2 é uma das opções mais usadas quando se necessita de uma interface para os projetos. Isso porque ele é barato e relativamente simples de usar. Além do fato de que é possível encontrar shields para o Arduino, facilitando bastante o processo de montagem do circuito.

 

O que é

A sigla LCD significa Liquid-Crystal Display, isto é, um display de cristal líquido. Isso implica que ele é um componente capaz de formar “imagens”.

O LCD está presente em diversos equipamentos, mas, neste caso, nós vamos falar do LCD 16×2 que é um componente pequeno, comparado com as televisões LCD. E ele pode ser programado facilmente usando as bibliotecas já existentes, tanto para o Arduino (AVR), quanto para o PIC ou outro microcontrolador em questão.

Fonte: Wikipedia

O fato dele ser 16×2 significa que ele é capaz de mostrar 16 caracteres por linha e que ele possui duas linhas. Se você tiver interesse em saber como programar o display sem usar a biblioteca pronta, os dois pdfs abaixo são muito interessantes e podem te ajudar muito nesse processo:

 

Características

 

 

O display em si é só o que está na placa verde da imagem acima. Mas, como é o caso da imagem, é possível encontrar shields ou módulos que acoplam o display em uma placa. Isso serve para facilitar a ligação do display com o Arduino e para adicionar alguns componentes interessantes a mais.

O shield da imagem, por exemplo, acompanha 6 botões (normalmente conectados ao A0) que auxiliam bastante a criar aplicações em que o usuário tem que interagir com o display. E também tem um potenciômetro para regular o brilho.

Pinos

O LCD 16×2 contem 16 pinos, pela ordem:

1. GND ou Vss – Pino de alimentação que deve ser ligado ao GND
2. Vcc ou Vdd – Pino de alimentação que deve ser ligado no 5V (Pode variar em torno de 4,7V – 5,3V)
3. VO ou Vee – Pino que regula o contraste. Quanto maior for a tensão (0-5v), mais o display ficará nítido.
4. RS – Pino para controlar o display. Quando recebe sinal baixo seleciona o registrador de comando e, quando recebe sinal alto, seleciona o registrador de dados.
5. RW – Pino de leitura ou escrita. Quando recebe sinal baixo entra no modo escrita e, quando recebe sinal alto, entra no modo leitura.
6. E – Manda dados para os pinos de dados quando um pulso de sinal alto para baixo é dado.
7. ao 14. D0 à D7 – Pinos de dados. Normalmente o display é controlado no modo 4bits, ou seja, usa-se só do D4 ao D7.

15. e 16. A (ou Led+) e K (ou Led -) – Pinos que alimentam o LED responsável pela luz de fundo do display.

Circuito

Se você possui um shield, então basta encaixá-lo no Arduino. Mas, se esse não for o seu caso, a ligação do display com o Arduino está mostrada abaixo:

 

 

Apesar de parecer complicado, é um circuito bem simples até. O pino GND deve ser ligado ao GND do Arduino. O Vdd ao 5v. O VO deve ser ligado ao terminal central de um potenciômetro e os outros pinos do potenciômetro devem ser ligados, um ao GND e o outro ao 5v. Se você quiser eliminar o potenciômetro, tente ligar o VO direto ao GND. O pino RW deve ser ligado ao GND.

Em relação aos pinos de dados, você pode mudá-los, mas vou mostrar a ligação padrão: o pino RS deve ser ligado ao pino 12 do Arduino, o pino E ao pino 11, e do pino D4 ao D7, devem ser ligados do pino 5 ao pino 2 respectivamente.

Os ultimos dois pinos (A e K) talvez não precisem ser ligados, portanto teste sem ligá-los para economizar recursos. Se não funcionar, basta ligar um resistor (não tem valor exato, recomendo 220Ω) no pino A e a outra ponta do resistor no 5v. E o pino K deve ser ligado no GND. Feito isso, basta programar.

 

Programação

Comandos de inicialização

Vamos utilizar a biblioteca pronta que já vem com a IDE do Arduino, que é a LiquidCrystal. Nos exemplos, é possível encontrar diversos códigos interessantes para poder testar o display, mas vamos entender os comandos básicos:

A instância (uma forma de referenciar o display dentro do código) do lcd precisa ser definida e fazemos isso com o seguinte comando:

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

Os números correspondem aos pinos que ligamos anteriormente. Traduzindo para ficar mais fácil entender.

LiquidCrystal lcd(pino Rs, pino E, D4, D5, D6, D7);

Então, se você deseja ligar os pinos de dados diferente do circuito que mostrei, é só lembrar de mudá-los na programação também. No caso do shield que mostrei, a pinagem certa é a seguinte:

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

Enfim, o segundo passo é iniciar o display:

lcd.begin(16, 2);

 

O 16,2 se refere justamente aos 16 caracteres e as duas linhas que mencionei anteriormente.

 

Comandos de escrita

Agora, basta usar o display como você quiser, e os comandos que vão te ajudar nesse processo são:

• lcd.print(“AlgumaCoisa”);
  • Se você quiser escreve algo, é só usar esse comando. Retire as aspas e coloque o nome de uma variável para printar o valor dela.
• lcd.setCursor(0, 0);
  • Obvio, você não quer sair escrevendo em qualquer lugar, e pra isso existe o comando acima que define a posição do cursor, que é a posição onde o LCD irá escrever a partir do momento que o comando foi digitado. O primeiro parâmetro define a coluna e o segundo a linha. Por padrão, a escrita ocorre em 0,0 que é: na primeira linha, a partir da primeira coluna.
• lcd.clear();
  • Esse comando basicamente limpa a tela e volta o cursor pra 0,0.
  • Ele pode ser um pouco lento para ser executado, então talvez seja mais interessante limpar o display utilizando o comando lcd.print(”     “) com vários espaços.

Criando Caracteres

O LCD ainda te permite criar caracteres customizados, isto é, criar símbolos para você printar no display. Cada quadrado do display, que representa um caractere, possui 8 quadradinhos menores no sentido vertical e 5 no sentido horizontal. Então, para criar símbolos, você deve desenhar usando esses quadradinhos e isso é feito da seguinte forma:

1 2 3 4 5 6 7 8 9 10

byte heart[8] = { //Codigo que está no exemplo da biblioteca do liquidcrystal   0b00000,   0b01010,   0b11111,   0b11111,   0b11111,   0b01110,   0b00100,   0b00000 };

Onde cada linha que começa com 0b representa uma linha de quadradinhos. O 0 representa um quadrado apagado e o 1, um quadrado aceso. Então, basta desenhar o seu símbolo usando 1s e 0s. Repare que no código acima (simbolo de um coração), os números 1s formam um coração, de fato.

Caso você tenha dificuldades nessa parte, existe um programa que desenvolveram no Excel que gera o código do símbolo automaticamente a partir de um desenho que você fizer. E você pode baixar ele aqui.

Agora que nós desenhamos o símbolo, precisamos ainda fazer duas coisas. A primeira é declarar para o programa o símbolo:

lcd.createChar(0, heart);

No primeiro parâmetro, você coloca o número ao qual seu símbolo está endereçado, no exemplo acima é o 0. E, depois coloca o nome da variável que está guardado seu desenho. No exemplo acima, fizemos o desenho do coração na variável chamada heart. Por fim, a segunda etapa é desenhar o símbolo. Defina onde quer colocá-lo (a posição do cursor) e use o comando:

lcd.write(0);

O número dentro do parêntese é o número que você definiu como o “endereço” do símbolo. No nosso exemplo, o simbolo do coração está endereçado ao 0.

Exemplo de códigos

 

//Programa: Teste de Display LCD 16 x 2
//Autor: FILIPEFLOP
 
//Carrega a biblioteca LiquidCrystal
#include <LiquidCrystal.h>
 
//Define os pinos que serão utilizados para ligação ao display
LiquidCrystal lcd(22,23, 24, 25, 26, 27);
 
void setup()
{
  //Define o número de colunas e linhas do LCD
  lcd.begin(16, 2);
}
 
void loop()
{
  //Limpa a tela
  lcd.clear();
  //Posiciona o cursor na coluna 3, linha 0;
  lcd.setCursor(3, 0);
  //Envia o texto entre aspas para o LCD
  lcd.print("FILIPEFLOP");
  lcd.print("\n");
  lcd.print("ANDERSON OK");
  lcd.setCursor(3, 1);
  lcd.print(" LCD 16x2");
  delay(5000);
   
  //Rolagem para a esquerda
  for (int posicao = 0; posicao < 3; posicao++)
  {
    lcd.scrollDisplayLeft();
    delay(300);
  }
   
  //Rolagem para a direita
  for (int posicao = 0; posicao < 6; posicao++)
  {
    lcd.scrollDisplayRight();
    delay(300);
  }
}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() {   lcd.begin(16, 2); } void loop() {   lcd.clear();   lcd.setCursor(2, 0);   lcd.print("Bem-vindo ao");   lcd.setCursor(0, 1);   lcd.print("Mundo Projetado");   delay(3000);   lcd.clear();   lcd.setCursor(1, 0);   lcd.print("Curta a pagina");   lcd.setCursor(3, 1);   lcd.print("no Facebook");

 Fonte:\\

http://mundoprojetado.com.br/display-lcd-com-arduino/

 

 

 

Read More

Kernel panic

 

Fonte:www.google.com

 Kernel panic, em português Pânico do núcleo, é uma situação em que sistemas operacionais Unix e tipo Unix encontram um erro do qual não é possível recuperar-se de modo seguro. No sistema operacional Windows a mesma situação é apresentada com a Tela azul da morte (em inglês: Blue Screen of Death). 

 

Kernell Panic - Ubuntu

Fonte:www.google.com

 

 

Há uma rotina no código fonte do Linux e dos sistemas BSD chamada panic(), que trata uma situação de pânico do núcleo. Ela é projetada para mostrar uma mensagem no console, gravar uma imagem da memória do núcleo no disco para depuração após a falha e então aguardar o sistema ser reiniciado manualmente, ou reiniciar automaticamente. A informação fornecida para a tela é técnica, e é direcionada aos desenvolvedores de software e administradores de sistema para que possam diagnosticar o problema.

Fontes comuns de pânicos do núcleo são tentativas do sistema operacional ler endereços de memória não permitidos, ou falhas no hardware. Outro motivo é a existência de um erro no próprio sistema. Em muitos casos esta situação é induzida pelo próprio sistema, que pode continuar a operação, mesmo depois de violações de memória terem ocorrido. No entanto, nesta situação o estado do sistema é instável, e mais do que arriscar brechas de segurança ou corrupção de dados, é preferível terminar a operação para evitar mais danos, e facilitar o diagnóstico do erro.

O pânico do núcleo foi incluído numa versão inicial do Unix e demonstrou uma grande diferença de filosofia entre o Unix e o Multics. O desenvolvedor do Multics Tom van Vleck, relembra uma discussão com o desenvolvedor do Unix Dennis Ritchie:

Eu comentei com o Dennis que facilmente metade do código que eu estava escrevendo no Multics era para recuperação de erros. Ele disse: "Deixamos tudo isso de fora. Se houver um erro, temos uma rotina chamada panic, que quando é chamada, trava a máquina e você grita lá no corredor, 'Ei, reinicie.'"^[1]

A função original permaneceu essencialmente inalterada desde a quinta edição do Unix até o Unix 32V baseado no VAX apenas emitindo uma mensagem de erro sem mais informações, deixando o sistema num looping infinito. Na medida em que o Unix foi melhorado, a função panic() foi aprimorada para exibir várias informações úteis para depuração no console. 

 

Fonte:

 

https://pt.wikipedia.org/wiki/Kernel_panic

Read More

Processadores CISC X RISC: qual a diferença entre essas duas arquiteturas?

 Capacidade e modo de processamento. Ao final deste post, você vai concluir que essas são as principais diferenças entre as arquitetura CISC e RISC. Mas para chegar lá, vamos começar do início.    

O que o processador faz?

Considerado o cérebro de um computador, o processador – ou Unidade Central de Processamento (CPU) – é um circuito eletrônico responsável por executar uma série de instruções dadas pela máquina.   Essas instruções são pré-definidas e armazenadas na memória principal do computador e chegam ao processador em linguagem assembly, que é o padrão reconhecido e compreendido por ele.   O processador pode receber diferentes tipos de instrução:

• Operações aritméticas (adição, subtração, multiplicação e divisão);
• Acesso à memória para, por exemplo, mover dados de um local para outro;
• Operações lógicas;
• Controle, etc...

 É aqui que as diferenças entre RISC e CISC começam a surgir. CISC é o acrônimo de Complex Instruction Set Computer, ou seja, executa instruções complexas.

 E qual é a complexidade por trás dessas instruções?  

• Elas são normalmente longas e repletas de operações matemáticas distintas.
• Não possuem um tamanho padrão, podendo assumir dimensões variáveis de acordo com a quantidade de operações que deverão ser executadas.
• Exigem que o processador acesse a memória para executar essa instrução.

Resultado: o tempo de processamento será maior afetando, portanto, a capacidade de processamento.  Para executar uma só instrução, um processador CISC pode exigir vários ciclos de relógio. Um ciclo de relógio é a frequência medida em Hertz que determina quantos impulsos serão realizados por segundo naquele computador.  

Exemplo, uma máquina de 100Mhz irá realizar 100 milhões de impulsos por segundo. Quanto maior esse número, menor será a quantidade de ciclos necessários para executar uma instrução.   A família de processadores x86 da Intel (286, 386, 486) nascida na década de 1970 é uma das mais reconhecidas usuárias da arquitetura CISC. E, durante anos, os computadores pessoais se restringiram a essa arquitetura até que a Apple mudou esse cenário.   “Podemos dizer que 90% do mercado têm suas demandas atendidas por máquinas com processador CISC. São usadas, normalmente, para rodar aplicações simples que exigem pouco processamento como um sistema de caixa de uma loja, por exemplo”, afirma o Diretor de Operações da LB2, Victor Machado.

 Devido à capacidade de processamento limitada, são logo substituídas pela arquitetura RISC, quando a necessidade de processamento atinge padrões elevados.

RISC ( Reduced Instruction Set Computer)

Aqui o nome mais uma vez diz muito sobre a arquitetura do processador. Ao contrário do CISC, o RISC executa instruções reduzidas. 

Ou seja, ele quebra a instrução em várias menores e mais simples e todas assumem um tamanho padrão.   Cada uma dessas instruções têm as características necessárias para que possa ser executada em apenas um ciclo de relógio. No exemplo que demos antes, a cada 100 milhões de impulsos, uma instrução seria concluída.

No caso do CISC, essa afirmação não seria verdadeira já que uma instrução poderia exigir 10, 20 ou vários outros ciclos para ser finalizada.   “Em nível enterprise, em que o processamento dos dados é muito alto, máquinas com arquitetura RISC como a Power da IBM e Sparc da Oracle são as mais indicadas. E aqui não estamos nos referindo necessariamente ao tamanho da empresa. Organizações de pequeno e médio porte podem ter operações que exijam capacidade de processamento muito alto e, por isso, recorrem ao RISC”, detalha Victor.  

O RISC também é amplamente utilizado em dispositivos móveis como celulares e tablets, os próprios notebooks e vídeo-games, pois são processadores menores, mais baratos e que tendem a consumir menos energia. Sem contar que atende à forte demanda por uma velocidade de processamento elevada nestes casos.  

 

CISC	RISC
Instruções completas que exigem vários ciclos de relógio para serem executadas	Instruções simples executadas em um ciclo de relógio
Instruções com formatos variáveis	Instruções com formatos fixos

 

Apesar de parecer menos vantajosa frente à arquitetura RISC, a CISC possui um conjunto maior de instruções que podem ser precessados, enquanto no RISC, o volume de instruções além de mais limitado, é mais simples.   Existem sim aplicações muito específicas para a arquitetura CISC e, por isso, a tendência é que ambas continuem coexistindo no mercado. Inclusive, há uma tendência de fusão dos dois tipos de processadores, permitindo que as instruções mais complexas sejam direcionadas para RISC e as mais simples e rápidas para CISC.

Para saber exatamente qual se encaixa melhor nas necessidades do seu negócio, conte com a ajuda dos especialistas da LB2.

Fonte:

https://www.lb2.com.br/blog/processadores-cisc-x-risc-qual-a-diferenca-entre-essas-duas-arquiteturas

Read More

Reiniciar a interface de rede em linha de comando no Linux

 

No caso da instalação de uma rede, principalmente para verificar se um servidor DHCP atribui corretamente os endereços IP, pode ser mais rápido reiniciar a interface de rede em linha de comando do que através de uma interface gráfica. Estes comandos devem ser executados em root (administrador) ou pelo sudo. 

Os comandos abaixo são específicos da distribuição Debian (e as distribuições que se baseiam nela, como Ubuntu ou Xandros): 

Parar a interface rede eth0:

ifdown eth0

Iniciar a interface rede eth0: 

ifup eth0

Isto não deve ser confundido com o comando que segue, que relança explicitamente todos os serviços de rede 

 

/etc/init.d/networking restart

Observação: para conhecer diferentes interfaces de rede, utilize o comando /sbin/ifconfig -a

Read More

IP fixo no Linux

 

Os arquivos utilizados para fixar IP em uma placa de Rede de uma distribuição Linux baseada no sistema Debian é diferente dos sistemas baseados na distribuição RedHat, neste artigo vou apresentar os passos necessários para fazer isso numa distribuição baseada no Debian.

Para configurar endereço IP fixo numa distribuição baseada no Debian, é necessário editar o arquivo:

/etc/network/interfaces

No exemplo abaixo é definido o IP para a interface eth0:

allow-hotplug eth0

iface eth0 inet static

address 192.168.1.5

netmask 255.255.255.0

network 192.168.1.0

broadcast 192.168.1.255

gateway 192.168.1.1

dns-nameservers 192.168.1.1 8.8.8.8 # Servidores de DNS

para verificar se a placa esta instalada e reconhecida pelo sistemas operacional, pode-se usar o comando:

# ifconfig -a

Esse comando vai listar a placa mas sem nenhum endereço de IP, até que ela receba um IP.

Para configurar um endereço de IP na placa sem sem fazer as alterações nos arquivos de configuração os comandos são os seguintes.

 

# ifconfig eth0 192.168.1.5 netmask 255.255.255.0 up

# route add default gw 192.168.1.1

Essas configurações serão perdidas quando o Sistema Operacional for reinicializado.

Read More

Outra forma de bloqueando portas com IPtables

Com as invasões de PCs, máquinas zumbis e outras coisas que podem ser um incômodo (principalmente quando se trata de um servidor), medidas de segurança nunca são demais.

Hoje, eu vou mostrar um simples script que criei para o IPtables. Eu fiz isso no Slackware 14.0, mas você poderá também executar este script em outra distribuição.

Bloqueando portas de entrada: 

 

 #!/bin/sh
#Iptables configuração.
#Script criado por Pangas

iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
iptables -A INPUT -p tcp --destination-port 80 -j DROP
iptables -A INPUT -p tcp --destination-port 443 -j DROP
iptables -A INPUT -p tcp --destination-port 22 -j DROP
iptables -A INPUT -p tcp --destination-port 1234 -j DROP
iptables -A INPUT -p tcp --destination-port 21 -j DROP
iptables -A INPUT -p tcp --destination-port 12345 -j DROP
iptables -A INPUT -p tcp --destination-port 20 -j DROP 

 

Explicação:

A opção -A INPUT diz que o Firewall deverá bloquear todas as portas de entradas que forem definidas. Nesse caso, eu resolvi criar um script que possa ser usado tanto em computadores domésticos, quanto em servidores.

Podem ver, que eu bloqueei também a porta do X e a porta padrão do NetBus. Pois fiquei sabendo de patches para GNU/Linux. Nenhum sistema operacional é 100% seguro, tanto que, até o Android da Google também é infectado.

A opção -p indica o protocolo. Você pode usar TCP ou UDP.

Já a --destination-port indica a porta de destino. Ou seja, qual serviço deve ser bloqueado ou liberado pelo IPtables. A opção -j DROP indica que a porta será bloqueada. Deve ser definida logo após a porta destino.  

Fonte:

https://www.vivaolinux.com.br/dica/Bloqueando-portas-com-IPtables

Read More

Tutorial: Liberando portas no Firewall [Windows/Linux]

 Olá,

Abaixo você descobrirá como liberar portas no Firewall de seu sistema operacional.

Antes de tudo, você deve saber o protocol (TCP/UDP) utilizado pela porta na qual você deseja liberar.

Windows

Abra o "Control Panel" e clique em "Check firewall status" (Control Panel\System and Security\Windows Firewall).

Na aba esquerda selecione a opção "Advanced Settings". Será aberto uma nova janela, então clique em "Inbound rules".
Após clicar, será listado todas as aplicações/portas de seu Firewall, porém você deverá selecionar a opção "New rule..." localizada na aba direita da janela.

Selecione a opção "Port" e prossiga.
Selecione o protocolo da porta na qual você deseja adicionar, por exemplo, TCP para porta 80.
Selecione a opção "Specify local ports" e insira o número da porta no qual deverá ser liberada e prossiga.
Selecione a opção "Allow the connection" para liberar a conexão dessa porta e prossiga.
Selecione todos os campos de checkbox e prossiga.
Insira um nome para a porta e prossiga.

Após completados estes passos, sua porta já vai estar liberada para conexões externas.

Caso qualquer bloqueio esteja sendo feito mesmo com os procedimentos acima e já ter se passado 2 horas após a liberação de seu serviço (tempo necessário para o Firewall de nossa rede se configurar) selecione a opção "Turn Windows Firewall on or off" e desative ambos firewalls selecionando a opção "Turn off *".

Linux

Para liberar portas no Firewall de seu servidor Linux, utilize o comando "iptables".

A sintaxe para uso é a seguinte: iptables -I INPUT -p tcp --dport 80 -j ACCEPT
INPUT: a direção do tráfego (INPUT = ENTRADA).
-p: o protocolo utilizado pela porta (no caso tcp/udp).
--dport: o número da porta onde o tráfego irá passar (80, 443, 6667).

Caso queira liberar uma porta UDP para um jogo, SA:MP por exemplo:
iptables -I INPUT -p udp --dport 7777 -j ACCEPT

Caso queira liberar uma porta TCP para Minecraft:
iptables -I INPUT -p tcp --dport 25565 -j ACCEPT

Caso queira simplesmente liberar todo o tráfego em todas as portas:
iptables -F; iptables -X

Caso qualquer bloqueio de tráfego continue após 2 horas de servidor liberado/on-line, contate o suporte técnico para investigarmos o problema.

 Fonte:

https://customer.heavyhost.com.br/knowledgebase.php?action=displayarticle&id=3

Read More

Como habilitar e desabilitar a placa de rede em Linux

 Linux interage com cada placa de rede através de uma construção de sistema operacional chamado de " interface de rede. " As interfaces de rede apresentam um conjunto uniforme de primitivas para aplicações que requerem acesso à rede, ao esconder os detalhes específicos de hardware do adaptador e os parâmetros de configuração para o seu condutor . Em particular, você pode ativar e desativar uma placa Ethernet , executando comandos do Linux que interagem com a interface de rede correspondente. Instruções
 

1

Log no computador Linux.
 

2

Inicie um shell de comando . O modo específico de executar este passo depende da distribuição Linux e de como sua máquina foi configurado. Por exemplo, para a configuração padrão do Ubuntu Linux , clique em "Aplicativos" na barra de tarefas na parte superior da área de trabalho e selecione " Acessórios " e selecione "Terminal ".
 

3

obter privilégios de superusuário digitando "su" no shell, em seguida, a tecla " Enter". Digite a senha de root. . Caso a sua distribuição Linux não tem uma conta "root" ativada por padrão , digite " sudo bash" e digite sua senha quando solicitado
 

4

Digite o seguinte comando no shell :

ifconfig

Pressione " Enter". O comando irá listar as interfaces de rede conhecidos Linux. . " Eth "; Encontre o correspondente à placa Ethernet que você precisa para ativar ou desativar o seu nome começará com
 

5

Ativar a placa Ethernet , digitando o seguinte comando no shell :

ifconfig eth0 up

Substitua o " eth0" com o nome da interface de rede obtido no Passo 4. Pressione " Enter".
 

6

Desabilite a placa Ethernet , digitando o seguinte comando no shell : 

ifconfig eth0 down 

Substitua o " eth0" pelo nome da interface de rede , obtido no Passo 4 . Pressione " Enter". 

 

Fonte: http://ptcomputador.com/Networking/ethernet/65808.html

Read More

Liberando portas com o IPTables

 

Passo 1

Acesse o seu Cloud Server Linux via SSH com o seu usuário Root,

Passo 2

Em seguida de o comando iptables -A INPUT -p tcp --dport 22 -j ACCEPT

Regras do IPtables.

INPUT = regras de entrada.
OUTPUT = regras de saída.
FORWARD = regras de roteamento.

iptables-save
iptables-restore

-A = Adiciona uma regra ao final da tabela do IPTABLES (iptables -A INPUT ...)
-D = Apaga a regra da tabela (iptables -D INPUT --dport 80 -j DROP)

-p = especifica o protocolo a ser utilizado
-s = especifica o endereço do origem
-d = especifica o endereço de saída

 

Fonte:

 

https://atendimento.redehost.com.br/hc/pt-br/articles/210810567-Liberando-portas-com-o-IPTables

 

Read More