Placa Intel® Galileo ​(Gen 1) 
 
 
 
Manual de uso geral 
 

Revisão 1 

Por: Acácio Azevedo, Dênis Gomes e Tiago Matos 

Em: 19 de agosto de 2016 

 
Índice 

1. Introdução 

2. Especificações técnicas 

3. Indicação de itens na placa 

4. Instalação 

5. Aplicação de exemplo (Blink) 

6. Instalando o Sistema Operacional (SO) no SDcard 

7. Solução de problemas 

8. Referências 

 
1. Introdução 
 

Apresentamos  a  placa  microprocessada  Galileo,  que  é  baseada  no  processador  Intel® 

Quark SoC X1000, um SoC (system on chip) de 32 bits da classe do Pentium. 

Está  placa  também  foi  desenvolvida  para  ter  compatibilidade  da  pinagem,  tanto  a  nível  de 
software quanto de hardware, com shields Arduino projetados para o Uno R3. 

Isto  porque  seus  pinos  digitais  de  0  a  13  (incluindo   os  AREF  e  GND),  suas  entradas 
analógicas  0  a  5,  o  power  header,  o   ICSP  header,  e  os  pinos  de porta UART (0 e 1), estão 
nas mesmas posições tais quais o Arduino Uno R3.  

A  tensão  de  operação  no  núcleo  da  placa  é  3.3   volts.  Contudo,  um  jumper  contido  nela 
permite  uma  tradução  à  tensão  de  5  volts  nos  pinos  de  entrada  e  saida.  Assim,  a  placa 
Galileo  pode  suportar  shields operando  em 3.3 V ou 5V. Dando  suporte as shields  Uno de 5 
volts,  o  que é o comportamento padrão. Isto é, a qualquer momento essa tradução pode ser 
desabilitada de modo a fornecer 3.3 volts nos pinos de E/S. 

Ainda, a placa é compatível com o ambiente de desenvolvimento do Arduino. 

No  mais,  além   dessa  compatibilidade,   a  Galileo  possui  diversas  portas  de  entrada  e  saída 
que  são  padrões  na  industria  de  PCs  e  também  recursos  para  expandir  seu  uso  e 
capacidade para além das opções dadas pelos shields Arduino. 

São  eles,  um  slot  mini­PCI  Express,  uma  porta  Ethernet  de  100Mb,  um slot Micro­SD, uma 
porta  serial  RS­232,  uma  porta USB Host, outra porta USB Cliente, e uma memória flash de 
8 MBytes. Todos incluídos por padrão. 

Para  a  criação  de  todo  o  conteúdo  deste  manual  e  a  execução  dos  testes  realizados  na 
Placa Galileo, foi utilizada a plataforma Windows 7 e/ou Windows 8.1. 

 
 
 
 
 
 
 
 
 
 
 

 
2. Especificações técnicas 
 

2.1 Processador: 
➢ Intel® Quark SoC X1000 

➢ De 32 bits 

➢ Single core e single thread 

➢ Clock de 400 MHz 

➢ Conjunto de instruções (ISA) compatível com o Intel® Pentium. 

➢ 16 KBytes de cache L1 

➢ 512 KBytes de SRAM on­die 

➢ Suporte a ACPI 

➢ Real Time Clock (RTC) integrado 

2.2 RAM: 
➢ 256 MBytes DDR3 

2.3 Portas: 

➢ Conector Ethernet 10/100 

➢ Slot mini­card PCI Express (mini­PCIe) 

➢ Porta host USB 2.0 no conector mini­PCIe 

➢ Conector USB 2.0 host 

➢ Conector USB client, usada para programação 

➢ JTAG header padrão de 10 pinos para depuração 

➢ Porta serial RS­232 

2.4 Armazenamento: 

➢ Flash de 8 MBytes  para firmware (ou bootloader) e o último sketch. 

➢ Entrada para cartão microSD. 

 
2.5 Características elétricas: 

➢ Tensão de entrada (recomendada): 5V 

➢ Tensão de entrada (limites): 5V 

➢ Pinos digitais de E/S: 14 (6 provendo saída PWM) 

➢ Pinos de entrada analógica: 6 

➢ Corrente de saída DC total em todas as linhas de E/S: 80 mA 

➢ Corrente DC para pino de 3.3V: 800 mA 

➢ Corrente DC para pino de 5V: 800 mA 

3. Indicação de itens na placa 

 
Imagem 01: Módulos da Placa Intel Galileo 

 
4. Instalação 
 

4.1 Energia 

A  placa  é  alimentada  por  um  adaptador  de   corrente  AC  para  DC,  que  deve  ser  conectado 
ao  jack  incluso  na  mesma,  por  um  plug  de  2.1  mm  com  o  positivo  no  centro.  A  saída 
recomendada para o adaptador é de 5 volts em até 3 amperes. 

4.2 Ligando 

Para  iniciar  a  operação   com  a  placa  Galileo,  é  imperativo  que  as  operações  sejam 
efetuadas na seguinte ordem: 

Primeiro,  ligá­la  à  sua   alimentação   de  energia  por  meio  do  adaptador  de  corrente  AC  para 
DC de 5 volts. 

Em seguida, aguardar a estabilização do led ON e o led de indicação do USB ligar. 

Finalmente,  conectar o cabo micro­USB entre o computador  e a placa, utilizando para isso a 

porta USB cliente presente na mesma. 

 
Imagem 02: Placa conectada a fonte de alimentação e USB 

 
4.3 Ambientes de desenvolvimento (IDE) 
Existem três ambientes de desenvolvimento que podem ser utilizados para  desenvolvimento  
com a placa Galileo. 

Para  utilizar  as  linguagens  C/C++  ou  Java,  o   ambiente  será  o  Intel®  System  Studio  IoT 
Edition.  Que  é  um  plugin  para   a  IDE  Eclipse,  e  permite  a  programação  de  projetos  IoT 
(internet of things), além de oferecer bibliotecas especiais. 

Para utilizar JavaScript, o ambiente será agora o Intel® XDK IoT Edition. 

Ela  suporta  projetos  embarcados  com   JavaScript  usando  o  node.JS,  e  provê  um  ambiente  
abrangente  suportando  desenvolvimento  plataforma­cruzada,  para  a  criação  de  aplicações 
híbridas HTML5 web e mobile. 

A terceira opção, e a que focaremos neste manual, é utilização da IDE Arduino. 

No  site   da  Intel,  é  possível   encontrar  a  IDE  do  Arduino  customizada  para  operação  com 
placas Galileo e também Edison. 

A última versão (IDE 1.6.0, Intel 1.0.8), pode ser encontrada neste link: 

https://downloadcenter.intel.com/download/24355/Intel­Galileo­Board­Software­Package?pr
oduct=78919 

Há versões disponíveis para os sistemas operacionais Windows, Linux e MacOS X. 

Instruções detalhadas da instalação em cada plataforma se encontram em: 

https://software.intel.com/en­us/get­started­arduino­install 

 
4.4 Conhecendo a Ferramenta 

Ao  iniciar  a  ferramenta  a  mesma  irá  apresentar  uma  tela  com  os  seguintes  botões  e 
informações. 

 
Imagem 03: Tela principal da IDE. 

1 ­ Verificar: Compila e Aprova. 

2 ­ Upload: Carrega na memória do Galileo, o sketch1 escrito. 

3 ­ Novo: Abre um novo Sketch em branco. 

4 ­ Abrir: Abre um sketch feito anteriormente. 

5 ­ Salvar: Salva o sketch aberto. 

6 ­ Monitor Serial: Abre um monitor contendo informações seriais, usado para correção de        erros no código. 

7 ­ Nome do Sketch: Nome dado ao Sketch aberto. 

8 ­ Área do Código: Local onde é digitado o código. 

9 ­ Área de Mensagem: Local de retorno ao usuário se o código possui algum erro. 

10 ­ Console em texto: Apresenta a descrição dos erros encontrados. 

11 ­ Placa e Porta Serial: Identifica a placa e a porta utilizada. 

1
 Os programas escritos usando o Arduíno Software (IDE) são chamados sketches. Os sketches são 
escritos no editor de texto e salvos com extensão de arquivo .ino. O editor possui características de 
copias/colagens e procura/substituição de texto. A area de mensagem retorna ao usuário um feedback 
do status do programa enquanto o salva e exporta. A saída de texto do display do console inclui o 
retorno completo de mensagens de erro e outras informações.  
 
4.5 Usando a Placa 

Depois  de  ligar  e  conectar  a  placa  ao  computador,  abra  a  IDE,  clique  em  ferramentas, 
depois em placa e escolha Intel Galileo. Conforme a figura abaixo: 

 
Imagem 04: Configuração da Placa Intel Galileo na IDE. 

 
Novamente vá em ferramentas, escolha porta e marque a porta para comunicação: 

 
Imagem 05: Configuração na IDE da porta de comunicação. 

5. Aplicação de exemplo (Blink) 
A  IDE  Arduino  vem  com  alguns  programas  de  exemplo  que  podem  ser  utilizados  para 
explorar  os  recursos  disponíveis  na  placa.  Para  acessá­los,  a  partir  da  janela  principal  da 
IDE,   clique  em  “File”   ou  “Arquivo”,  vá  em  “Examples”  ou  “Exemplos”,  onde  podem  ser 
encontrados os exemplos disponíveis divididos por catergorias. 

Uma  aplicação  extremamente   simples,  e  que  pode   ser  usada  para  testar  o  correto  
funcionamento da instalação, é a “Blink”. 

A  partir  da  janela principal da IDE, clique em “File” ou “Arquivo”, vá em “Examples” no menu 

que se abrirá aponte para o primeiro item “01. Basics” e  depois clique em “Blink”. 

 
  
Imagem 06: Acesso ao exemplo Blink. 

Abrirá  uma  nova  janela  com  o código  do exemplo. Como o  programa escrito já está  correto, 

não  é  necessário  fazer a verificação (função do botão “1” da IDE, com  ícone de “v”), apenas 
fazer  o  upload  para  a  placa.  Esta  é  a  função  do  botão  “2”  da  IDE,  aquele  com  o   ícone  de 
seta  à  direita  “→”.  Após  o  upload  concluído  com  sucesso,  observe  na   placa  Galileo  o  LED 
PIN 13 piscar. 

 
  
Imagem 07: Funcionamento do exemplo Blink na Placa. 

6. Instalando o Sistema Operacional (SO) no SDcard 
A  placa  possui  entrada  para  cartão  micro  SD,  como  o  sistema  operacional possui tamanho 
maior que 1 GB, será preciso obter um cartão micro SD de 2 GB ou mais. 

Para  a  realização  dessa  etapa,  além   de  utilizar  uma  imagem  do  Linux,  também  será 
necessário  um software para grava­lá no cartão micro SD, da  IDE Arduino para obtenção do 
IP  da  placa  quando  a  mesma  estiver  conectada  a  uma  rede  ethernet,  e  um  cliente  SSH 
(secure shel) como o PuTTY, para logar remotamente no Linux. 

Para  a  realização  e  instalação do ambiente Linux na placa intel Galileo, certifique­se de que 

foi feito o download correto da imagem no site oficial da intel. 

Em: ​https://software.intel.com/en­us/iot/hardware/galileo/downloads 

Procure por: ​Latest Yocto* Poky Image​ (210 MB), 

 
Imagem 08:Localização para realizar download da Imagem Linux. 

 
Baixe  o  software  para   gravar  a  imagem  de  disco  (Win32  Disk  Imager),  e   instale  no 
computador. Este pode ser encontrado no seguinte link: ​ ​http://goo.gl/0yYp3j 

 
Imagem 09: Imagem ilustrativa do software Win32 Disk Imager. 

Baixe o software de comunicação SSH (PuTTY), que pode ser encontrado no link: 

 ​http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html 

 
Imagem 10: Localização para realizar o Download do PuTTY.  

 
Agora  já   com  todos  os   downloads  feitos,  conecte  o  cartão  micro  SD  ao  computador, 
formate­o em FAT 32 ou FAT (padrão).  

 
Imagem 11: Formatação da unidade de armazenamento.  

Feito  isso,  procure  o arquivo que foi baixado da imagem Linux. Ele estará compactado, faça 

a descompressão do arquivo. 

 
Imagem 12: Descompressão do arquivo. 

 
Abra  o  Win32  Disk,  marque  a  unidade  onde  a  imagem  será  gravada,  ou  seja,  o  seu cartão 
micro  SD,  adicione  o  aquivo  descompactado  da  imagem  Linux  e  clique  em  Write.  O 
programa  salvará  o  SO  no  cartão,  após  o  fim  do  procedimento  ele   apresentará  uma 
mensagem de sucesso. 

 
Imagem 13:Processo para gravação do SO na unidade de armazenamento . 

Após  essa  etapa,  iremos  ligar  a  placa.  Para  isso  colocaremos  o  cartão  SD  na  placa, 
ligaremos  a  fonte,  o   usb  e  o  cabo  ethernet.  No  computador,  abriremos  a  IDE,  faremos  o 
mesmo  precedimento  para  a  escolha  da  placa  de  da  porta  e  escreveremos  um  programa 
como apresentado na imagem abaixo: 

 
Imagem 14: Escrito do programa na IDE. 

 
Salve  o  programa,  faça  a  verificação   e  posteriormente,  o  upload  para  a  placa.  Feito  isso, 
clique  no  botão  do  monitor  serial.   Abrirá  uma  janela  que  apresentará  o  endereço  IP  que  a 
placa esta recebendo. 

 
Imagem 15: Apresentação do IP na IDE. 

Abra  o  Putty,  digite  o  IP  da  placa, em “Port” deixe 22, e em “Connection type” marque SSH. 

Depois é só clicar em “Open”. 

 
Imagem 16: Layout do PuTTY. 

 
À  primeira  vez   que  o programa abre, ele exibe uma mensagem de segurança, que pode ser 
ignorada bastando apenas clicar em “Sim”. 

 
Imagem 15: Mensagem de Segurança.. 

Agora  ele  ira  carregar,  e  aparecerá  na  tela  pedindo  o  login,  digite  ​root  e  dê  enter.  Pronto 
você já tem acesso ao sistema. 

 
Imagem 16: Acesso ao sistema com usuário e senha. 

 
7. Solução de problemas 

Depois  de  algumas  tentativas  sem  sucesso  de  comunicação  ao  usar  a  placa  com a versão 
IntelArduino  1.6.0,  no  windows  8.1.  Verificou­se  a  necessidade  de  atualização  do firmware, 
mas o driver encontrado no site apresentou erros na execução e não foi possível atualizar. 

A  solução  encontrada  foi  baixar  uma   versão   anterior  da   IDE  a  IntelArduino 1.5.3 em inglês, 

que contém dentro dela um atualizador de firmware. 

7.1 Atualizando Firmware  

Antes  de  executar  os passos de atualização do firmware, foi necessário alterar a região2 e o 

idioma  configurada  na  plataforma  Windows  de  português  (Brasil)  para  inglês  (Estados 
Unidos).  Somente  após  esse  passo,  foi  possível  realizar  o  update  do  firmware  na  placa 
Galileo.  Com  a  placa  ligada  e  conectada  ao  computador,  abra  a  IDE  IntelArduino  1.5.3, 
clique em Help, depois em Galileo Firmware Update. 

 
Imagem 17: Atualizando Firmware da Placa Intel Galileo. 

2
 Em “Painel de Controle” do Windows, acesse a opção “Relógios, Idioma e Região” e altere a Região e 
o idioma (Localização inicial), caso você esteja no formato Brasil. 
 
Dê  OK  e  siga  as  instruções  até  a  instalação  ser  completada.  Se  o  processo travar no meio 
da atualização, desligue tudo e repita a operação. 

 
 Imagem 18: Confirmação para atualização do Firmaware. 

 
7.2 Workarrounds para bugs na versão 1.6.0 no Linux: 

7.2.1 Erro 1: 
File "/home/hank/Arduino/hardware/tools/relocate_sdk.py", line 98 
Setting it up...SDK could not be set up. Relocate script failed. Abort! 
print  "ERROR:  could  not relocate  %s,  interp size  =  %i  and  %i  is needed." %  (elf_file_name, 
p_memsz, len(new_dl_path) + 1) 
                                                                           ^ 
SyntaxError: invalid syntax 

Solução: 

O  sistema  operacional  usa  Python  3  por  padrão,  enquanto  a  IDE  usa  o  Python  2.  Instale  o 
Python 2, se já não o tiver, e na pasta da IDE execute os seguintes comandos: 
ln ­s python2 python 
ln ­s python2­config python­config 

Que criará symlinks para redirecionar os comandos do python para a versão 2. 

7.2.2 Erro 2: 
find: invalid mode ‘+111’ 

Setting it up...SDK could not be set up. Relocate script failed. Abort! 

Solução: 

Em  versões  mais  novas  do  comando  find,  o  uso  dos  argumentos  ​­perm ​­mode  não  é  mais 
suportado. Assim, a partir da raiz da pasta do programa, abra o arquivo: 

./hardware/tools/install_script.sh 

Localize a linha que contém isso: 
executable_files=$($SUDO_EXEC  find  "$native_sysroot"  ­type  f  ­perm  +111  ­exec  printf  
"\"%s\" " {} \; ) 

E substitua a parte +111 por /111 

 
8. Referências 

● Página oficinal: ​https://software.intel.com/pt­br/iot/hardware/galileo 
● Guia de início de uso: ​https://software.intel.com/pt­br/iot/library/galileo­getting­started 

● Downloads diversos: ​https://software.intel.com/en­us/iot/hardware/galileo/downloads 

● Artigo sobre a placa Galileo no site oficinal do projeto Arduino: 
https://www.arduino.cc/en/ArduinoCertified/IntelGalileo 
● Datasheet da placa: 
http://www.intel.com/content/www/us/en/embedded/products/galileo/galileo­g1­datas
heet.html 
● Guia para instalação de SO Linux no SD card: 
https://software.intel.com/en­us/get­started­galileo­windows­step1 
● Vídeo sobre ainstalação de SO Linux no SD card: 
https://www.youtube.com/watch?v=uIzaDJ4fm3k