Electronic ++: ARM

Mostrar mensagens com a etiqueta ARM. Mostrar todas as mensagens

domingo, 14 de dezembro de 2014

Raspberry Pi : OS

Instalar um Sistema Operativo no Raspberry Pi

Após uns largos meses depois da comprar do meu Raspberry Pi B decidi finalmente tirá-lo da gaveta e começar a dar lhe algum utilidade.

O Raspberry Pi é um pequeno computador de baixo consumo que permite correr um sistema operacional linux, existem milhões de projectos onde pode ser utilizado.

Especificações:

	Modelo A	Modelo B	Modelo B+
SoC	Broadcom BCM2835 (CPU + GPU)
CPU:	700 MHz ARM11 ARM1176JZF-S core
GPU:	Broadcom VideoCore IV
RAM	256 MB	512 MB	512 MB
USB 2.0:	1	2	4
Vídeo output	S-VIDEO \| HDMI
Áudio output	3.5 mm Jack \| HDMI
Áudio input	Pode ser adicionada uma placa de som por USB
Armazenamento:	Cartão SD		Cartão microSD
Network:	--	Ethernet RJ45 (10/100)
Periféricos:	26 Pinos GPIO SPI, I²C, I²S, UART		40 Pinos GPIO SPI, I²C, I²S, UART
Consumos:	300 mA, (1.5 W)	700 mA, (3.5 W)	650 mA, (3.0 W)
Alimentação:	5 VDC (USB B, GPIO)
Dimensões:	85.0 x 56.0 mm x 15mm	85.0 x 56.0 mm x 17mm	85.0 x 56.0 mm x 17mm
Peso:	31g	40g	40g

Material necessário:

Para começar a trabalhar com o Raspberry Pi apenas é necessário um cartão de memória SD com o tamanho mínimo de 4GB,

Outros periféricos podem ser utilizados como um monitor com entrada HDMI, uma televisão com entrada S-Video, um teclado e rato USB, uma pen USB wireless, neste mundo a imaginação é o limite. :)

Instalação Sistema Operativo

Existe um conjunto de sistemas operativos que podem ser utilizados, uns baseados em linux outros não. Eu vou utilizar a distribuição Raspbian.

Antes de mais é preciso fazer download da ISO com o sistema operativo e do utilitário Win32DiskImager.

Seleccionar a Image File e o Device e gravar.

Esperar até finalizar o processo.

Depois de gravado o sistema operativo está instalado. Colocar o cartão no Raspberry Pi, ligar ao router com um cabo de rede e ligar à alimentação.

Configurar Sistema Operativo

Depois de alimentado o Raspberry Pi vai começar a arrancar com o sistema operativo. Depois de aguardar mais ou menos 1 minuto podemos proceder as configuração. O servidor de SSH vem activo por defeito o que permite aceder ao Raspberry Pi através de uma ligação SSH.

Credencias:

user: pi

pass: raspberry
hostname: raspberrypi

Atráves do mRemoteNG é possível ligar remotamente à shell do Raspberry Pi através de SSHv2. Basta correr o comando "sudo raspi-config" para configurar o Raspberry Pi.

Downloads:

Referências:

terça-feira, 9 de dezembro de 2014

Raspberry Pi : Instalar Oracle JDK 1.8

Instalar JDK 1.8 no Raspberry Pi

Vamos instalar a máquina virtual do java no Raspberry Pi. Vamos instalar o JDK 1.8. Depois de fazer o download do site da Oracle da versão para ARM devemos copiar para o Raspberry Pi o ficheiro de instalação ( jdk-8u6-linux-arm-vfp-hflt.tar.gz ).

O software WinSCP permite a transferência de dados entre um computador e um computador remoto, neste caso o Raspberry Pi.

Depois de transferir os dados para o Raspberry Pi basta executar os seguintes comandos na shell para instalar e configurar o java,

Extrair para o JDK para /opt/java:

$ sudo tar zxvf jdk-8u6-linux-arm-vfp-hflt.tar.gz /opt/java

Criar links simbólicos para acesso ao java:

$ sudo update-alternatives --install /usr/bin/javac javac /opt/java/jdk1.8.0_06/bin/javac 1

$ sudo update-alternatives --install /usr/bin/java java /opt/java/jdk1.8.0_06/bin/java 1

$ sudo update-alternatives --config javac

$ sudo update-alternatives --config java

Verificar instalação:

$ java -version

$ javac -version

Downloads:

Referências:

Raspberry Pi : Instalar Apache Tomcat 8

Instalar Apache Tomcat 8 no Raspberry Pi

O Apache Tomcat é um servidor aplicacional opensource Java. Vamos instalar e fazer uma pequena configuração.

Fazer o download do site da Apache Tomcat (apache-tomcat-8.0.15.tar.gz)

$ wget http://mirrors.fe.up.pt/pub/apache/tomcat/tomcat-8/v8.0.15/bin/apache-tomcat-8.0.15.tar.gz

Extrair para /opt/tomcat

$ tar -xzvf apache-tomcat-8.0.15.tar.gz /opt/tomcat

Editar o ficheiro:

$ sudo nano /etc/init.d/tomcat8

Inserir o texto seguinte:

###############################################
CATALINA_HOME=/opt/tomcat
  PATH=/sbin:/bin:/usr/sbin:/usr/bin
  start()
  {
      sh $CATALINA_HOME/bin/startup.sh
  }
  stop()
  {
      sh $CATALINA_HOME/bin/shutdown.sh
  }

  case $1 in
      start|stop) $1;;
   restart) stop; start;;
   *) echo “Run as $0 “; exit 1;;
  esac
################################################

Alterar as permissões:

$ sudo chmod 777 /etc/init.d/tomcat8

Iniciar o serviço tomcat:

$ sudo service start tomcat8

Neste momento já temos o nosso servidor a correr e podemos testar acendo a porta 8080 do Raspberry Pi.

Para conseguir aceder as configurações do servidor é necessário configurar o ficheiro tomcat-users.xml.

$ sudo nano /opt/tomcat/conf/tomcat-users.xml

Adicionar as seguintes linhas e gravar:

<role rolename="manager-gui"/>
<role rolename="admin-gui"/>

<user username="yourUser" password="yourPassword" roles="manager-gui,admin-gui"/>

As seguintes opções estão neste momento disponíveis.

Gestor de Aplicações

Estado do servidor

Downloads:

Referências:

http://tomcat.apache.org/

domingo, 5 de outubro de 2014

MDK uVision 5.12 - ChibiOS - Demo

Configurar ChibiOS + MDK uVison

Surgi mais um projecto e associado a isso sempre mais dificuldades. Hoje comecei o desenvolvimento de um novo projecto com base na placa Mini STM32 v3 já referida anteriormente.

Foi alterado o ambiente de desenvolvimento de Linux para Windows, neste caso, Windows 8.1.

Todos já devem conhecer o Keil MDK-5 uVision confesso que apesar de já ter ouvido falar foi o meu primeiro contacto, devo dizer que me surpreendeu pela positiva, a curva de aprendizagem é relativamente pequena e tem todas as vantagens de ser um IDE. Em relação a velocidade e tamanho do código gerado pelo compilador também existe pontos a favor versus o GCC.

Antes de mais defini a minha estrutura de pasta, na minha opinião, uma boa estrutura da pasta é fundamental para um desenvolvimento rápido em sistemas embebidos.

Na raiz são adicionadas todas as bibliotecas, dentro da pasta projects as placas de desenvolvimento existentes, e dentro de cada placas as aplicações desenvolvidas.

Na configuração do uVision foi utilizado como exemplo a placa Mini STM v3, mas é o procedimento é igual para todas a placas, sendo necessário ter em contas as características específicas de cada uma.

Depois de criado o projecto é necessário configurar as Options for Target:

Target: Define o hardware de destino, tamanho e endereçamento de de ROM e RAM. É necessário definir o campo IRAM2 no endereço seguinte ao fim da RAM para utilizar com o ChibiOS.

C/C++: Configuração referente ao compilador, includes, optimização, defines, etc. Para utilizar com o ChibiOS é necessário includir todos os ficheiros .h utilizados no projecto.

É necessário incluir os seguintes símbolos e alterar o chconf.h:

#define CH_USE_MEMCORE FALSE

#define CH_USE_HEAP FALSE

define: __heap_base__=Image$$RW_IRAM1$$ZI$$Limit __heap_end__=Image$$RW_IRAM2$$Base

ASM: Mais um vez é necessário fazer os includes dos ficheiros utilizados nos ASMs.

Debug: Utilizei o programador e debugger ST-Link v2, mas é possível utilizar qualquer um existente na lista.

Utilities: Aqui escolhe-se a placa a destino e o programador para fazer o download do código.

Após estas configurações, têm a placa configurada, para utilização do ChibiOS, contudo poderá ser necessário adicionar mais include paths. Agora vamos configurar o projecto. O uVision faz a gestão de todos os ficheiros de código adicionados, por isso é necessário adicionar todos os ficheiros de kernel, hal, port e da aplicação para ser possível compilar.

Utilizei o seguinte estilo de grupos:

Por fim temos o nosso resultado :)

Downloads:

Projecto MDK-5.12 uVision

Referencias:

Keil ARM

Chibios e Keil

quinta-feira, 10 de julho de 2014

GNU Toolchain ARM Cortex-M (64bits)

Ambiente de Desenvolvimento para Cortex-M

Hoje decidi reinstalar o meu computador com o Fedora 20 64-bits, e decidi escrever de forma muito simples os passos para criar o ambiente de desenvolvimento para a minha placa actual (stm32f4 discovery).

GNU Toolchain ARM

Para executar os binário da GNU Toolchain ARM é necessário dar suporte a 32-bits, a instalação dos pacotes a baixo permite ao sistema operativo correr binários de 32-bits.

yum install glibc.i686
yum install ncurses-libs.i686

A toolchain da GNU está disponível para vários sistemas operativos e disponibiliza também as fontes, sendo o Fedora um sistema operativo baseado em unix vamos fazer o download última versão para Linux. Dentro da hierarquia de pastas do sistema Linux existe a "/opt" que é dedicada ao colocar software de terceiros, addons, etc por isso é um óptimo lugar para colocarmos as nossas ferramentas de forma arrumadinha.

Insight Debugger

Um programa de debug faz muita falta e esse não podia ficar esquecido, decidi instalar o Insight mais uma vês foi colocado na pasta "/opt". Antes de conseguir executar o insight é necessário instalar algumas dependências:

yum install libX11-devel.i686
yum install zlib-devel.i686
yum install expat-devel.i686

OpenOCD

Antes de compilar e instalar o openocd é necessário instalar algumas dependências:

yum install gcc
yum install git libtool autoconf texinfo libusb-dev
yum install libftdi

Depois das dependências instaladas é preciso fazer o download as fontes compilar e instalar, mais uma vez será instalado na pasta "/opt".

git clone git://openocd.git.sourceforge.net/gitroot/openocd/openocdcd openocd ./bootstrap
./configure --enable-maintainer-mode --disable-option-checking --disable-werror --prefix=/opt/openocd --enable-dummy --enable-usb_blaster_libftdi --enable-ep93xx --enable-at91rm9200 --enable-presto_libftdi --enable-usbprog --enable-jlink --enable-vsllink --enable-rlink --enable-stlink --enable-arm-jtag-ewmakesudo make install

UDEV

Para se conseguir executar o openOCD sem acesso root basta:

sudo cp /opt/openocd/share/openocd/contrib/99-openocd.rules /etc/udev/rules.d/
sudo udevadm control --reload-rules
usermod -a -G plugdev <utilizador>

Adicionar ao PATH

Para facilitar o desenvolvimento adicionei as pastas "bin" que contêm os binários ao PATH de modo a que possa ser chamado a partir de qualquer directório. A forma mais fácil é editar o script ".bashrx" onde é possível definir caminhos para ficheiros e funções do utilizador.

Downloads:
--

Referências: