Projeto: Criando um Servidor Web com Arduino e Ethernet Shield

Vamos colocar em prática a teoria mostrada na lição anterior sobre o shield ethernet no Arduino, criando um projeto simples com um Arduino Uno (outras placas também funcionam) e um Shield Ethernet: um Servidor Web, sistema que aceita solicitações de clientes e permite enviar dados como resposta. Por exemplo, podemos ter um sensor medindo a temperatura do ambiente, e consultar os valores medidos pela Internet ou rede local, usando um navegador que acessa o  Servidor Web configurado.

Neste tutorial vamos mostrar como usar um shield Ethernet e a classe EthernetServer para configurar um servidor de rede (web) com Arduino.

Lista de materiais

Vamos precisar de :

• 1 Shield Ethernet
• Arduino (Uno, Mega, etc)
• Cabo de Rede
• Roteador da sua rede local
• PC com navegador para testes

A seguir podemos ver o Shield Ethernet conectado a um Arduino Uno:

A Classe EthernetServer

A função desta classe é criar um objeto servidor que irá escutar (aguardar solicitações) requisições de conexão de clientes em uma porta específica, e então servir a esses clientes um serviço quando essa conexão é efetuada.

O primeiro passo para configurar um servidor web com Arduino e shield Ethernet é criar um objeto servidor, usando a sintaxe a seguir:

EthernetServer servidor = EthernetServer(porta);

Onde porta é o número da porta de comunicações na qual o servidor escutará. O padrão é a porta 80 para o serviço web.

Devemos inicializar a biblioteca Ethernet passando como parâmetro, no mínimo, o MAC address do shield Ethernet, como segue:

Ethernet.begin(mac);

Também é possível passar outros parâmetros de rede, com o ip, máscara de subrede e gateway padrão, caso utilizamos IP fixo, por exemplo:

Ethernet.begin(mac, ip, gateway, subrede);

O servidor será inicializado quando necessário invocando-se o método begin:

servidor.begin();

Classe EthernetCLient

Para começar a ouvir, é necessário também criar um objeto cliente, o qual irá representar o cliente real com o qual o servidor irá se comunicar. Para isso, usamos a classe EthernetClient, como segue:

EthernetClient cliente = servidor.available();

Esse objeto cliente retorna o valor falso (0) se não houver nenhum cliente disponível no momento.

Para fechar a conexão com um cliente, após a transmissão dos dados requisitados, por exemplo, usamos o método stop():

cliente.stop();

Consulte a descrição completa das funções de cliente e servidor no Arduino para saber mais sobre como usar essas classes.

Enviar e receber dados de um cliente

Usamos as funções print(), println() e write() para enviar dados a um cliente. Para receber (ler) dados do cliente, usamos o método read().

Código de exemplo (simplificados)

EthernetServer servidor = EthernetServer(80);
void setup() {
  Ethernet.begin(mac, ip, gateway, subrede);
  servidor.begin();
}
void loop() {
  EthernetClient cliente = servidor.available();
  if (cliente) {
    Serial.print(cliente.read());  // Ler dados do cliente e enviar para o monitor serial
  }
}

No exemplo, criamos um objeto EthernetServer de nome servidor, inicializando-o com o número da porta que será utilizada, no caso a porta 80 (padrão HTTP).

Na função de setup() inicializamos a biblioteca Ethernet, passando os dados de endereço mac, ip, gateway e máscara de subrede.

Na função loop() criamos o objeto EthernetClient, de nome cliente, que recebe o retorno do método servidor.available(), o qual verifica se o servidor está disponível. Caso esteja, será impressa no monitor serial um dado lido proveniente do cliente de rede.

O método available() retorna o valor 0 (zero) caso não haja um cliente disponível. Caso haja, o objeto cliente o representará.

Vejamos o código completo para a criação de um servidor web simples, que inclui a geração de um cabeçalho HTTP de resposta e o envio de uma página HTML ao cliente (navegador em um computador ou outro dispositivo)

Código para o servidor Web

Abaixo temos o código completo do sketch de nosso servidor web com Arduino:

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
EthernetServer servidor(80);

void setup() {
 Serial.begin(9600);
//Desativando o SD Card:
 pinMode(4, OUTPUT);
 digitalWrite(4, HIGH);
 
 Ethernet.begin(mac);
 servidor.begin();
 
 Serial.print("IP do servidor: ");
 Serial.println(Ethernet.localIP());
 Serial.print("Gateway: ");
 Serial.println(Ethernet.gatewayIP());
}

void loop() {
 EthernetClient cliente = servidor.available();
 if (cliente) {
   boolean linha_atual_branca = true;
   while (cliente.connected()) {
     if (cliente.available()) {
       char c = cliente.read();
       Serial.write(c);
 
       if (c == '\n' && linha_atual_branca) {
         // Criando o cabeçalho HTTP:
         cliente.println("HTTP/1.1 200 OK");
         cliente.println("Content-Type: text/html");
         cliente.println("Connection: close");
         cliente.println("Refresh: 5");
         cliente.println();
         // Código da página Web a ser exibida:
         cliente.println("<!DOCTYPE html>");
         cliente.println("<html lang='pt-br'>");
         cliente.println("<head>");
         cliente.println("<meta charset='UTF-8'>");
         cliente.println("<title>Servidor Web com Arduino</title>");
         cliente.println("</head>");
         cliente.println("<body>");
         cliente.println("<hr>");
         cliente.println("<p>Bem-vindo à Bóson Treinamentos em Tecnologia!</p>");
         cliente.println("<hr>");
         cliente.println("</body>");
         cliente.println("</html>");
         break;
       }
     if (c == '\n') {
       // Iniciando uma nova linha
       linha_atual_branca = true;
     }
     else if (c != '\r') {
       // Há um caractere na linha atual
       linha_atual_branca = false;
     }
   }
 }
 // Tempo para o navegador receber os dados
 delay(1);
 // Fechar a conexão:
 cliente.stop();
 }
}    

Após carregar o sketch no Arduino, abrimos o monitor serial para verificar se um endereço IP foi atribuído corretamente ao shield ethernet:

Veja que foi atribuído o IP 192.168.1.109 ao shield ethernet. Vamos agora abrir um navegador no computador e acessar o endereço do nosso servidor web:

Note que também é possível usar um endereço IP fixo no servidor web, bastando para isso acrescentar a seguinte linha ao nosso código (logo após a declaração do endereço MAC), fornecendo o IP desejado, com seus números separados por vírgulas, como no exemplo:

IPAddress ip(192, 168, 1, 10);

E então alterar a instrução:

Ethernet.begin(mac);

para

Ethernet.begin (mac, ip);

Desta forma, será usado o IP fornecido no código, em vez de um endereço IP obtido a partir de um servidor DHCP na rede – o qual pode mudar de tempos em tempos, dificultando a tarefa de acessar o Arduino pela rede.

No próximo tutorial vamos mostrar como é possível enviar comandos a um Arduino a partir de um navegador, por meio da configuração do servidor Web.

O post A classe EthernetServer – Configurando um servidor web com Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma das formas mais importantes de comunicação disponíveis com o Arduino é o padrão Ethernet. Trata-se de um protocolo de comunicação em redes que permite que dispositivos variados, como PCs, smartphones, roteadores, arduinos, etc., se comuniquem por meio do envio e recebimento de pacotes (frames / quadros, para ser mais exato), que são fluxos de dados organizados.

Cada dispositivo em uma rede possui seu próprio endereço IP, que é um endereço numérico que permite identificar cada dispositivo e dessa forma, se comunicarem entre si usando diferentes protocolos (padrões de software).

Shield Ethernet

No Arduino é bastante simples realizar essa comunicação via padrão Ethernet, com o uso de um Shield Ethernet e sua biblioteca correspondente. A imagem a seguir mostra um shield ethernet típico:

O Shield Ethernet na plataforma Arduino utiliza o chip WIZnet W5100 Ethernet, que fornece a pilha de rede TCP/IP, habilitando o dispositivo a se comunicar através de uma rede comum, tanto local quanto via Internet.

Esse shield possui um conector para cabo de rede RJ45, e sua taxa de transferência máxima é de 100 Mbps, podendo operar também em 10 Mbps (10/100).

Além disso, ele traz um slot para cartão microSD, que permite ler e armazenar dados no próprio shield (obviamente inserindo um cartão SD e executando a biblioteca SD).

Um shield ethernet realiza, basicamente, o papel que uma placa de rede executa em um computador comum. Antes de mostrarmos como funciona e como configurar esse shield, vamos discutir alguns termos relacionados a redes de computadores, que serão importantes no entendimento do processo de comunicação do Arduino.

Conceitos básicos de Redes

• Ethernet: Tecnologia de rede que permite a dispositivos enviarem dados entre si por meio de uma rede com fios, por meio de um endereço físico (identificação de hardware).
• Endereço MAC: Media Access Control / Controle de Acesso ao Meio, trata-se de um identificador (endereço) único que é atribuído aos dispositivos de rede, de modo que cada dispositivo seja identificado de forma única e possam assim se comunicar com outros dispositivos. Cada shield Ethernet para Arduino possui seu próprio endereço MAC, que nunca se repete.
• Protocolo de Rede: Um protocolo é uma linguagem de comunicação padronizada que permite que dispositivos troquem informações entre si (“conversem”). Para que essa comunicação seja possível, os dispositivos devem usar o mesmo protocolo, como se fosse a mesma “linguagem”. Um protocolo muito comum é o protocolo HTTP, que permite configurar um servidor Web (que podemos fazer com Arduino!).
• TCP/IP: Trata-se de uma pilha ou suíte de protocolos específica, ou seja, um grupo de protocolos que trabalham em conjunto para fornecer conectividade de rede a dispositivos. TCP significa “Protocolo de Controle de Transmissão”, e IP significa “Protocolo de Internet”, e esses dois são os protocolos mais importantes da pilha, que na verdade contém mais de 50 protocolos diferentes, cada um com uma função bem definida.
• Endereço IP: O IP é um endereço lógico, ou seja, não associado fisicamente a um dispositivo, mas que permite que os dispositivos de identifiquem em uma rede como a Internet.
• Gateway: Um gateway, também chamado de Gateway Padrão, é basicamente o endereço IP da porta de um roteador conectada à rede interna, a qual permite o roteamento (encaminhamento) dos pacotes para uma outra rede, geralmente a Internet.

Shield Ethernet encaixado no Arduino

A Biblioteca Ethernet

A biblioteca Ethernet, necessária para que seja possível utilizar o shield correspondente, é distribuída juntamente com o IDE do Arduino e permite a comunicação do Arduino com uma rede.

A tabela a seguir fornece uma descrição simplificada de algumas das funções mais comuns da biblioteca Ethernet, pertencentes às classes Ethernet, EthernetClient, EthernetServer e EthernetUDP:

Ethernet.begin(mac)
Ethernet.begin(mac, ip)
Ethernet.begin(mac, ip, gateway)
Ethernet.begin(mac, ip, gateway,subnet)

Server(port)

Server.begin()

Server.write()

Server.available()

Server.print()

Server.println()

Client(ip. porta)

Client.connect()

Client.connected()

Client.write()

Client.print()

Client.println()

Client.available()

Client.read()

Client.flush()

Client.stop()

EthernetUDP.begin(port)

EthernetUDP.read(packetBuffer,
MaxSize)

EthernetUDP.write(mensagem)

EthernetUDP.beginPacket(ip. port)

EthernetUDP.endPacket()

EthernetUDP.parsePacket()

Ethernet.available()

Nas próximas partes desse tutorial, vamos mostrar como utilizar o shield Ethernet e as bibliotecas listadas acima para criar diversas aplicações de rede com o Arduino, como por exemplo um servidor Web e um cliente de rede local.

Próximo: Projeto – Criando um Servidor Web com Arduino e um Shield Ethernet

O post Como usar um Shield Ethernet no Arduino apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Nesta lição vamos conhecer três funções primordiais usadas no desenvolvimento de software para o Arduino: pinMode(), digitalWrite() e digitalRead().

Função pinMode()

Esta função permite configurar um pino específico para se comportar como um pino de entrada ou de saída.Por padrão, os pinos do Arduino tem a função de entrada, de modo que não é necessário declará-los neste caso. Já os pinos de saída devem ser configurados por meio dessa função, o que os leva a um estado de baixa impedância, de modo que eles podem fornecer corrente para outros circuitos. Os pinos do microcontolador Atmega podem fornecer até 40 mA de corrente para outros componentes ou circuitos.

Sintaxe da função:

pinMode(pino, modo)

Parâmetros:

• pino é o número do pino que queremos configurar.
• modo pode ser: INPUT (entrada), OUTPUT (saída), ou ainda INPUT_PULLUP.

O parâmetro INPUT_PULLUP permite habilitar os resistores de pullup, os quais são desabilitados quando é usado o modo INPUT. A função pinMode() não retorna nenhum valor ao programa.

Exemplo: Queremos ajustar o pino 7, conectado a um sensor, como entrada, e o pino 8, conectado a um LED, como saída:

int sensor = 7
int LED = 8
void setup() {
  pinMode(sensor, INPUT);
  pinMode(LED, OUTPUT);
}

É muito comum usarmos a função pinMode() dentro da seção setup(), para efetuar as configurações de pinos iniciais do programa.

Função digitalWrite()

Esta função escreve um valor HIGH (alto) ou LOW (baixo) em um pino digital que tenha sido configurado como OUTPUT (saída). O valor HIGH equivale a uma tensao de 5V (ou 3,3V em algumas placas), e o valor LOW, a uma tensao elétrica de 0V.
Caso o pino tenha sido configurado como INPUT (entrada), a função digitalWrite() irá habilitar ou desabilitar o pullup interno do pino de entrada. Esta técnica não é recomendada, sendo idela usar a função pinMOde para habilitar o resistor de pullup.
Os pinos analógicos também podem ser utilziados como pinos digitais, sendo referenciados com pinos A0, A1, etc.

Sintaxe:

digitalWrite(pino, valor)

Parâmetros:

• pino: é o número do pino considerado
• valor: HIGH ou LOW

Exemplo: Usando a listagem do exemplo anterior, vamos agora escrever um nível alto no pino onde o LED será conectado (pino 8), esperar meio segundo (500 ms), e então apagr o LED, escrevendo o nível LOW no pino. Ou seja, vamos acender e apagar o LED a cada meio segundo:

int sensor = 7
int LED = 8

void setup() {
  pinMode(sensor, INPUT);
  pinMode(LED, OUTPUT);
}

void loop() {
  digitalWrite(LED, HIGH);
  delay(500);
  digitalWrite(LED, LOW);
  delay(500);
}

Função digitalRead()

Esta função permite ler o valor a partir de um pino digital especificado, sendo os valores possíveis HIGH ou LOW.

Sintaxe:

digitalRead(pino)

Parâmetro:

• pino é o número do pino cujo valor precisamos ler.

Esta função retorna um valor para o programa, alto (HIGH) ou baixo (LOW).

Exemplo: Usando o primeiro exemplo, vamos ler o valor que o sensor conectado ao pino 7 está enviando ao Arduino:

int sensor = 7
int LED = 8
int valorSensor = 0;
void setup() {
  pinMode(sensor, INPUT);
  pinMode(LED, OUTPUT);
}
void loop() {
  valorSensor = digitalRead(sensor);
}

Note que, como a função digitalRead() retorna um valor ao programa, precisamos armazenar esse valor em algum lugar, e para isso declaramos uma nova variável, a variável valorSensor, inicializada com o valor 0 (zero). Após a chamada à função, a variável terá o valor HIGH ou LOW, conforme o sinal enviado pelo sensor, e poderemos usar esse valor para decidir o que fazer posteriormente no programa. O que aprenderemos nas próximas lições!

Referência da Linguagem do Arduino

O post Arduino – Conhecendo as funções pinMode, digitalRead e digitalWrite apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O Intel Quark é uma família de SoCs (“System-on-chips”) de arquitetura de 32 bits da Intel, que são projetados para terem um baixíssimo consumo energético e também um tamanho físico reduzido, sendo chips que visam a mercados como IoT (Internet das Coisas), sistemas embarcados (embedded systems) e dispositivos vestíveis (wearables), onde o consumo de energia e form factor tem muita importância. São baseados no chip Pentium original.

Um SoC é um circuito integrado que integra todos os componentes de um computador (ou outro sistema eletrônico) em um único chip. São chips muito parecidos com microcontroladores, porém, possuem processadores mais poderosos, que podem inclusive executar softwares complexos como sistemas operacionais (Windows, Linux, etc).

Os chips dessa linha, de codenome “Clanton”, possuem algumas características peculiares, sendo as mais marcantes:

• Ausência de suporte a conjuntos de instruções SIMD (MMX, SSE, etc)
• Clock de 400 MHz (nos modelos atuais, 2015)
• Núcleos (Cores): 01
• Cache L2 16 KB
• Controladora de memória RAM DDR3-800, com suporte a ECC
• RAM: de 128 MB a 2 GB
• Potência dissipada total: 2,2W
• Socket: FC-BGA11E
• Dimensões: 15mm x 15mm
• Interfaces Ethernet: 02
• Suorte a barramento PCI Express
• USB 2.0, SD/SDIO/eMMC
• SPI, UART e I2C/GPIO
• Temperatura de operação: de -40ºC a +85ºC
• Custo: Entre 9 e 15 dólares

Um Datasheet com as especificações completas do Intel Quark pode ser obtido aqui (PDF, 934 páginas). O diagrama de blocos do chip pode ser visto na figura abaixo:

Diagrama de Blocos do SoC Intel Quark

Os núcleos dos chips Quark são menores do que os de um Intel Atom típico, com cerca de 1/5 do tamanho desses cores, consumindo até um décimo da potência consumida por eles. O primeiro chip da família, o X1000, foi apresentado durante o Intel Developer Forum de 2013, em San Francisco, Califórnia.

Aplicações

As principais aplicações dos SoCs Quark estão nas áreas automotiva, industrial e de energia. Os chips são componentes chave das sistemas de desenvolvimento Intel Galileo, Intel Edison e Intel Curie, e da futura placa Arduino 101 (Genuino 101 fora dos EUA).

Placa de desenvolvimento Intel Galileo com SoC Quark

O post O que é o Intel Quark apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A Black Duck Software, um provedor de soluções de software open source (OSS) e a  North Bridge, uma empresa de capital de risco, anunciaram os resultados da nona Pesquisa sobre o Futuro do Código Aberto. Eles descobriram que as empresas estão adotando software open source em massa, mas não estão gerenciando esse software de forma satisfatória.

Lou Shipley, CEO da Black Duck, disse em uma declaração “Nos resultados desse ano, se tornou mais evidente que as empresas precisam de gerenciamento e governança do código aberto para alcançar seu uso completo. Isso é crítico para reduzir riscos legais, operacionais e de segurança em potencial, ao mesmo tempo em que permite às companhias colher todos os benefícios que o software de código aberto fornece”.

The Future of Open Source 2015

Algumas das informações obtidas com essa pesquisa podem ser sumarizadas como segue:

• 78% dos respondentes disseram que suas empresas executam parte ou todas as suas operações em software open source e 66% disseram que suas empresas criam softwares para seus clientes baseados em código aberto. Esta estatística mais que dobrou desde 2010, quando 42% dos respondentes à pesquisa disseram que usam open source para tocar seu negócio ou em seus ambientes de TI.
• 93% dissearm que o uso de open source por suas empresas aumentou ou permaneceu no mesmo patamar no ano passado
• 64% das empresas atualmente participam em projetos open source – em contraste com 50% em 2014. Para os próximos 2 ou 3 anos, espera-se que 88% das empresas aumentem suas contribuições para projetos de código aberto.
• Sotfwares open source tem se tornado a abordagem padrão para o software com ais de 66% dos respondentes dizendo que levam em consideração softwares open source antes de tentar outras opções.

Além disso, a pesquisa também revelou que:

• 55% acreditam que software de código aberto são mais seguros quando comparados com soluções de software proprietário.
• 58% pensam que o open-source são mais dimensionáveis e 43% disseram que o open source fornece uma facilidade de implantação superior à de softwares proprietários.
• Ao avaliar tecnologias de segurança para uso interno, 45% disseram que as opções open source são as primeiras a serem consideradas.

Olhando para o futuro, aqueles que responderam à pesquisa vêem Cloud computing (39%), big data (35%), sistemas operacionais (33%), e a Internet das Coisas – IoT (31%) sendo impactadas por software de de código aberto nos próximos 2 ou 3 anos.

Estes números parecem baixos apesar disso. Por exemplo, à exceção de produtos de nuvem da Microsoft e VMware, praticamente todo o resto em termos de cloud é software opensource. Na verdade, a Microsoft também aderiu ao software open source em usa nuvem Azure com o Docker e a VMware tem sua própria nuvem OpenStack. Provavelmente a nuvem rodará OSS.

Porém, antes de ficarmos muito animados proclamando que o software open source “venceu”  e o software proprietário irá morrer, devemos levar em conta que as empresas ainda não possuem políticas formais de gerenciamento de open source. A pesquisa também descobriu que:

• Mais de 55% dos respondentes disseram que suas empresas não possuem procedimentos ou políticas formais para o uso de software open source. Além disso, apenas 27% possuem uma política formal de contribuições dos funcionários a projetos OSS.
• Apenas 16% possuem um processo de aprovação de código automatizado e menos de 42% mantém um inventório de componentes open source.
• Mais de 50% não estão satisfeitos com sua habilidade em compreender as vulnerabilidades de segurança conhecidas em componentes open-source, e apenas 17% planejam monitorar código open source para descobrir vulnerabilidades de segurança.

Open Source Initiative

Tudo isso é preocupante, mas há um problema ainda maior: as empresas muitas vezes vêem o software open source como algo “mágico” que é totalmente livre de problemas de segurança. É esse tipo de crença cega que levou, por exemplo, à falha de segurança Heartbleed.

De qualquer forma, é excelente que o software de código aberto esteja se tornando um favorito nas empresas. As empresas parecem finalmente estarem vendo o valor do modelo de desenvolvimento de software open source. Mas isso deve ser feito com  cuidado e planejamento para evitar problemas e trazer soluções de forma satisfatória.

Para saber mais sobre open source, visite o site da Open Source Initiative.

Fonte:  ZDNet

O post 78% das empresas usam Software Open Source apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Samsung lança chips Artik para Internet das Coisas

A Samsung revelou uma nova família de chips para serem usados na Internet das Coisas, colocando-a em competição direta com a Intel, Qualcomm e outras empresas na busca para conectar tudo.

Young Sohn, presidente da Samsung Electronics disse que a linha de processadores Artik combina hardware e software para auxiliar as empresas a construir rapidamente dispositivos conectados à Internet. Alex Hawkinson — CEO da companhia SmartThings, uma startup que desenvolve projetos para  Casas Inteligentes que a  Samsung adquiriu no ano passado – também revelou a nuvem aberta SmartThings que tornará mais fácil e mais rápido para os fabricantes de dispositivos e outras empresas criarem aplicações para os produtos.

Há três variantes do chip Artik: Artik 1, Artik 5 e Artik 10, nos quais cada chip possui poder de processamento maior e capacidades mais complexas. Os chips irão custar de menos de US$10 até cerca de US$100, disse Sohn, e serão destinados a tudo, desde simples dispositivos rastreadores até drones e hubs para casas inteligentes.

Tanto os chips quanto a nuvem SmartThings estão disponíveis hoje para serem usados em novos dispositivos da Internet das Coisas.

Artik 1

Artik 5

Artik 10

“O que é impotante é que estas são máquinas inteligentes que irão tornar nossas vidas melhores”,  disse Sohn durante um discurso na IoT World en San Francisco – CA

Os novos processadores da Samsung seguem um impulso semelhante à Intel. A empresa revelou em Janeiro uma plataforma de processadores para dispositivos vestíveis (wearables) denominada Curie. Esse dispositivo, do tamanho de um botão, inclui um processador, rádio Bluetooth de baixa energia, sensores e é capaz de funcionar por períodos de tempo estendidos com uma bateria do tamanho de uma moeda, ou ainda pode ser recarregado.

Porém o Curie, que é baseado em uma tecnologia de 32 nanômetros, não estará disponível até o segundo semestre do ano, o que dá uma vantagem ao chip Artik da Samsung.

A Samsung vem apostando alto na Internet das Coisas, que é o conceito de usar sensores e outras tecnologias para conectar basicamente tudo o que você pode imaginar à Internet. A empresa de análise Gartner prevê que o número de dispositivos conectados em rede irá disparar de cerca de 900 milhões de unidades em 2009 para 26 bilhões de unidades em 2020, transformando objetos e dispositivos comuns em dispositios inteligentes que podem se comunicar entre si.

De acordo com o IDC, o mercado de IoT baterá US$3.04 trilhões no ano de 2020.

Durante a mostra Consumer Electronics de 2015, em Janeiro, a Samsung, liderada pelo co-CEO Boo-Keun Yoon, prometeu que todos os produtos da companhia seriam construídos sobre plataformas que sejam abertas e compatíveis com outros produtos. Yoon também disse que 90% de seus dispositivos – desde smartphones até refrigeradores seriam capazes de se conectar à Internet até 2017.

Em cinco anos, todos os produtos em todo o  catálogo da empresa devem ser conectáveis à Internet. A Samsung enviou, no ano passado, cerca de 665 milhões de dispositivos por meio de suas divisões de dispositivos móveis e de eletrônicos.

A Samsung é a maior fabricante de chips de memória e também fabrica processadores para aplicações que servem como controladores de dispositivos, incluindo muitos dos iPhones da Apple.

O chip Artik mais avançado da Samsung usa a mesma tecnoogia que os processadores utilizados nos smatphones da empresa, de acordo com Sohn.

“Tudo já está ajustado, então porque nós não tiramos vantagem da tecnologia desenvolvida para os smartphones e a tornamos disponível para a Internet das Coisas?, ele perguntou durante a conferência.

A Boogio, uma startup que consegue transformar qualquer sapato em um “sapato inteligente” para propósitos como reabilitação, está usando o chip Artik 1 na quinta geração de seu dispositivo. E justamente porque a Samsung já combinou os chips, gerenciamento de energia e sensores, a Boogio pode, em vez disso, se focar em outras características e obter seus produtos mais rapidamente.

O chip Artik irá  “nos habilitar a levar nossa tecnologia para o próximo nível”, disse o CEO da Boogio, José Torres. “O Artik chega em uma hora muito crítica em nosso ciclo de desenvolvimento”.

Fonte: CNET

O post Samsung lança chips Artik para Internet das Coisas apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.