segunda-feira, 17 de agosto de 2015

Um pouco de propaganda

Bom dia pessoal,
Vim aqui hoje fazer propaganda do meu outro projeto: Projeto Jangada.
Quem quiser ajudar, será muito bem vindo.
Por enquanto é só!

terça-feira, 9 de junho de 2015

Programando em android com dados na "nuvem"

Bom dia pessoal,

Faz muito tempo que não escrevo, porém como estou num novo projeto, descobri umas ferramentas bem legais, e quis escrever aqui para compartilhar com vocês.

Bom, vou falar para vocês de um "framework" bem completo e no plano básico "grátis", conheçam o Parse.
Basicamente ele possibilita o armazenamento de dados na "nuvem", e para isso disponibiliza uma série de métodos e SDKs, para a maioria das linguagens utilizadas, "android, ios, c#, javascript, etc".
Ele também disponibiliza uma parte de "hospedagem" com node.

Agora vou focar na parte do android, com exemplos de como fazer a comunicação simples.

Primeiramente ele possui uma documentação bem explicada de todos os métodos e tudo que precisa saber. Android Guide
Com o guide deles vocês terão uma boa idéia de como fazer a comunicação e tudo mais, então vou colocar simplesmente uma classe de exemplo para que vocês possam utilizar, essa é a classe base que eu mesmo utilizo no meu projeto:


 import com.parse.Parse;  
 import com.parse.ParseException;  
 import com.parse.ParseObject;  
 public class Base {  
   protected String getParseClassName() {  
     return "";  
   }  
   public Base() {  
     backingObject = ParseObject.create(getParseClassName());  
   }  
   public Base(ParseObject object) {  
     setObject(object);  
   }  
   public void setObject(ParseObject object) {  
     backingObject = object;  
     setObject();  
   }  
   public void setObject() { }  
   public ParseObject getParseObject() {  
     return backingObject;  
   }  
   public void Save() throws ParseException {  
     getParseObject();  
     backingObject.save();  
     setObject();  
   }  
   protected ParseObject backingObject;  
   @Override  
   public int hashCode() {  
     return backingObject.getObjectId().hashCode();  
   }  
   @Override  
   public boolean equals(Object obj) {  
     if (obj == null)  
       return false;  
     if (obj == this)  
       return true;  
     return ((Base)obj).backingObject.getObjectId().equals(this.backingObject.getObjectId());  
   }  
 }  

Todas as classes de objetos do parse eu utilizo "extends Base" que basicamente ela possui um "ParseObject backingObject" o método "getParseClassName" serve para definir qual o nome da classe do objeto, seria a tabela do parse, eu deu override no hashcode e equals para comparar pelo ObjectId que é o id do parse.

Para vocês terem uma idéia de como utilizar essa classe base eu vou colocar uma classe simples que eu utilizo aqui:

 import com.parse.ParseException;  
 import com.parse.ParseObject;  
 import com.parse.ParseQuery;  
 import com.parse.ParseRelation;  
 public class Cidade extends Base {  
   public Cidade() {  
     super();  
   }  
   public Cidade(ParseObject object) {  
     super(object);  
   }  
   @Override  
   protected String getParseClassName() {  
     return "cidade";  
   }  
   public String getDescricao() {  
     return backingObject.getString("descricao");  
   }  
   @Override  
   public void setObject() {  
     //AQUI SERIA PARA COLOCAR RELAÇÕES COM OUTROS OBJETOS  
   }  
   @Override  
   public ParseObject getParseObject() {  
     ParseRelation relation = backingObject.getRelation("estado");  
     relation.add(estado.getParseObject());  
     return super.getParseObject();  
   }  
 }  


Espero que com isso vocês tenham um bom passo incial, e que comecem a pensar em utilizar o parse para envio de dados para nuvem.
Qualquer dúvidas/sugestões, etc podem postar no comentário que eu respondo.

Até a próxima!

quinta-feira, 27 de novembro de 2014

Dual-boot + Lollipop no Galaxy S3 (I9300)

Bom dia,
Hoje irei ensinar como fazer dual-boot e como colocar o lollipop (Android 5.0) no Galaxy S3 (i9300)
Irei partir do princípio que já temos um custom recovery instalado (CWM ou TWRP) na última versão, caso não tenha, clique no link para baixar e instalar o recovery.
Bom, primeira coisa que devemos fazer é instalar o arter97 kernel que irá possibilitar o dual-boot, e também possui várias funções, clique no link para ver todas as funções.
Se você não tiver root, baixe e instale também o superSU.zip
Download do superSU.zip
Download do arter97 kernel.
Copie o zip para o celular, case deseje copiar pelo adb (adb push "caminho para o kernel.zip" /sdcard/kernel.zip")
Agora reinicie o aparelho em modo recovery, desligue ele, e ligue segurando o botão Volume+, Home e Power ao mesmo tempo.
Ao entrar no recovery instale o zip (install zip from sdcard). Reinicie o aparelho, deixe ele bootar normalmente.
Após isso você estará rodando o kernel arter97, agora vamos instalar o dual-boot, baixe o multi-boot.zip do arter97, e já vamos instalar também o Android 5.0 (CyanogenMod 12)
Download do multi-boot.zip
Download da CM12
Download da GAPPs CM12
Após baixar os 3 arquivos, coloque no celular.
Reinicie ele em modo recovery
Instale o multi-boot.zip
SEM REINICIAR
Instale a CM12
Instale a GAPPs
Instale o arter97 kernel de novo
Reinicie.
Agora o celular vai reiniciar normalmente, e entrará na ROM que você já tinha.
Reinicie em modo recovery novamente
Instale de novo o multi-boot.zip
Instale o superSU.zip
Reinicie.
Quando ele ligar você vai ver na gaveta de apps um aplicativo chamado aSwitcher.
Abra o aplicativo e vai ter a opção de "Reboot to 2nd ROM"
Clique e ele irá rebootar na CM12, espere, pois o primeiro BOOT demora bastante.
Lembrando que todos os "known-bugs" estão nesse fórum (http://forum.xda-developers.com/galaxy-s3/development/wip-cyanogenmod-12-t2936990).
O teclado na CM12 só vai aparecer após você ir em configurações e habilitar o "hardware keyboard".

Agora você irá poder rebootar entre as 2 roms normalmente, testando a CM12 (Lollipop) mas continuando com a sua ROM que funciona tudo.

Até a próxima!

terça-feira, 26 de agosto de 2014

Android NDK, OpenGL ES, and Framework

Então, estava procurando tutoriais sobre openGL ES com android NDK (C++), mas existem poucos, e os mesmos não funcionam muito bem.
Por isso resolvi postar aqui tudo que eu passei para conseguir algo funcional (não digo 100% pois não consegui testar direito, mas está compilando).

Primeiramente eu uso o AndroidStudio, pois acho melhor do que o Eclipse, para configurar o NDK no studio, basta seguir esse tutorial: (NDK + Android Studio).

Após configurar tudo direitinho, você terá um diretório "jni" com o source em C++, eu não consegui fazer o gradle compilar automaticamente, então eu uso o ndk-build na pasta jni, e ele compila e joga para a pasta de libs correta.

Bom, além de tudo isso, como estou tendo que aprender tudo na raça, irei criar um framework para o openGL ES com android NDK, irei criar um repo no github para isso e depois postarei aqui novamente.
Se alguém estiver interessado em ajudar, seja programando, ou dando opniões, sempre será bem vindo.

Qualquer dúvida na configuração pode postar aqui. Até a próxima!

quarta-feira, 20 de agosto de 2014

Android Tutoriais - ContentProvider

Bom dia pessoal,
Comecei um projeto pessoal, e para facilitar a comunicação com o banco de dados sqlite, eu pesquisei um pouco sobre ContentProvider, e achei válido postar aqui um tutorial, sendo que com um ContentProvider, toda a parte de comunicação com o banco de dados fica bem mais simples.

ContentProvider serve para comunicar com o sqlite no android e retornar cursor com os registros sem a necessidade de montar um sql para todo comando, ele também é responsável por toda operação CRUD (create, read, update, delete) do aplicativo.

Bom para começar vamos definir uma tabela, criando uma classe para isso:

public class TutorialTable {
    //Tabela do BD
    public static final String TABLE_TUTORIAL = "tutorial";
    public static final String COLUMN_ID = "_id";
    public static final String COLUMN_DESCRICAO = "descricao";

    // SQL para criar a tabela
    private static final String DATABASE_CREATE = "create table "
            + TABLE_TUTORIAL
            + "("
            + COLUMN_ID + " integer primary key autoincrement, "
            + COLUMN_DESCRICAO + " text not null "
            + ");";

    public static void onCreate(SQLiteDatabase database) {
        database.execSQL(DATABASE_CREATE);
    }

    public static void onUpgrade(SQLiteDatabase database, int oldVersion,
                                 int newVersion) {
        database.execSQL("DROP TABLE IF EXISTS " + TABLE_TUTORIAL);
        onCreate(database);
    }
}


A classe da tabela é bem simples, primeiro definimos uma variável om o nome da tabela e das colunas (para acessar mais tarde), depois definimos o SQL para criar a tabela, e o upgrade (para quando mudarmos alguma coluna, aqui para facilitar ele da DROP e depois CREATE novamente, mas se não quiser ter perda de dados, poderíamos apenas usar ALTER TABLE para adicionar e remover colunas, porém teríamos que controlar as versões, como aqui é apenas para testes vou utilizar a maneira mais fácil.


Depois criaremos uma classe que será o DatabaseHelper, que fará a criação do BD e a atualização do mesmo.

public class DatabaseHelper extends SQLiteOpenHelper {

    private static final String DATABASE_NAME = "tutorial.db";
    private static final int DATABASE_VERSION = 1;

    public IGDatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    // Método chamado ao criar o BD
    @Override
    public void onCreate(SQLiteDatabase database) {
        TutorialTable.onCreate(database);
    }

    // Método chamado na atualização do BD, se você mudar o DATABASE_VERSION ele irá chamar esse método
    @Override
    public void onUpgrade(SQLiteDatabase database, int oldVersion,
                          int newVersion) {
        TutorialTable.onUpgrade(database, oldVersion, newVersion);
    }
}

Pronto, temos nossa tabela e nosso BD funcionando, lembrando que para cada tabela é bom criar uma classe diferente, e lembrar de adicionar o onCreate e onUpgrade no databasehelper.
Agora só falta a classe que será responsável pela comunicação com o BD, que será nosso ContentProvider.

public class CustomContentProvider extends ContentProvider {
    private DatabaseHelper database;

    private static final String AUTHORITY = "com.caioketo.tutorial.contentprovider";

    // ------- Definimos URIs uma para cada tabela
    private static final String PATH_TUTORIAL = "tutorial";

    public static final Uri CONTENT_URI_TUTORIAL = Uri.parse("content://" + AUTHORITY
            + "/" + PATH_TUTORIAL);


    // ------- Configurando o UriMatcher
    private static final int TUTORIAL = 10;
    private static final int TUTORIAL_ID = 20;
    private static final UriMatcher sURIMatcher = new UriMatcher(UriMatcher.NO_MATCH);
    static {
        sURIMatcher.addURI(AUTHORITY, PATH_PERGUNTAS, TUTORIAL);
        sURIMatcher.addURI(AUTHORITY, PATH_PERGUNTAS + "/#", TUTORIAL_ID);
    }

    @Override
    public boolean onCreate() {
        return false;
    }

    //@Override
    public Cursor query(Uri uri, String[] projection, String selection,
                        String[] selectionArgs, String sortOrder) {

        // Vamos utilizar o queryBuilder em vez do método query()
        SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();

        int uriType = sURIMatcher.match(uri);
        switch (uriType) {

            case TUTORIAL_ID:
                // Adicionamos a coluna ID
                queryBuilder.appendWhere(TutorialTable.COLUMN_ID + "="
                        + uri.getLastPathSegment());
                //$FALL-THROUGH$
            case TUTORIAL:
                queryBuilder.setTables(TutorialTable.TABLE_PERGUNTA);
                break;

            default:
                throw new IllegalArgumentException("Unknown URI: " + uri);
        }
        SQLiteDatabase db = database.getWritableDatabase();
        Cursor cursor = queryBuilder.query(db, projection, selection,
                selectionArgs, null, null, sortOrder);
        // Notificamos caso exista algum Listener
        cursor.setNotificationUri(getContext().getContentResolver(), uri);

        return cursor;
    }

    public String getPATH(int pathID) {
        switch (pathID) {
            case TUTORIAL:
                return PATH_PERGUNTAS;
            default:
                return "";
        }
    }

    @Override
    public String getType(Uri uri) {
        return null;
    }

    @Override
    public Uri insert(Uri uri, ContentValues values) {
        int uriType = sURIMatcher.match(uri);
        SQLiteDatabase sqlDB = database.getWritableDatabase();
        int rowsDeleted = 0;
        long id = 0;
        switch (uriType) {
            case TUTORIAL:
                id = sqlDB.insert(TutorialTable.TABLE_TUTORIAL, null, values);
                break;
            default:
                throw new IllegalArgumentException("Unknown URI: " + uri);
        }
        getContext().getContentResolver().notifyChange(uri, null);
        return Uri.parse(getPATH(uriType) + "/" + id);
    }


    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        int uriType = sURIMatcher.match(uri);
        SQLiteDatabase sqlDB = database.getWritableDatabase();
        int rowsDeleted = 0;
        switch (uriType) {
            case TUTORIAL:
                rowsDeleted = sqlDB.delete(TutorialTable.TABLE_TUTORIAL, selection,
                        selectionArgs);
                break;
            case TUTORIAL_ID:
                String id = uri.getLastPathSegment();
                if (TextUtils.isEmpty(selection)) {
                    rowsDeleted = sqlDB.delete(TutorialTable.TABLE_TUTORIAL,
                            TutorialTable.COLUMN_ID + "=" + id,
                            null);
                } else {
                    rowsDeleted = sqlDB.delete(TutorialTable.TABLE_TUTORIAL,
                            TutorialTable.COLUMN_ID + "=" + id
                                    + " and " + selection,
                            selectionArgs);
                }
                break;
            default:
                throw new IllegalArgumentException("Unknown URI: " + uri);
        }
        getContext().getContentResolver().notifyChange(uri, null);
        return rowsDeleted;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection,
                      String[] selectionArgs) {

        int uriType = sURIMatcher.match(uri);
        SQLiteDatabase sqlDB = database.getWritableDatabase();
        int rowsUpdated = 0;
        switch (uriType) {
            case TUTORIAL:
                rowsUpdated = sqlDB.update(TutorialTable.TABLE_TUTORIAL,
                        values,
                        selection,
                        selectionArgs);
                break;
            case TUTORIAL_ID:
                String id = uri.getLastPathSegment();
                if (TextUtils.isEmpty(selection)) {
                    rowsUpdated = sqlDB.update(TutorialTable.TABLE_TUTORIAL,
                            values,
                            TutorialTable.COLUMN_ID + "=" + id,
                            null);
                } else {
                    rowsUpdated = sqlDB.update(TutorialTable.TABLE_TUTORIAL,
                            values,
                            TutorialTable.COLUMN_ID + "=" + id
                                    + " and "
                                    + selection,
                            selectionArgs);
                }
                break;
            default:
                throw new IllegalArgumentException("Unknown URI: " + uri);
        }
        getContext().getContentResolver().notifyChange(uri, null);
        return rowsUpdated;
    }

    private void checkColumns(String[] projection) {
        String[] available = { TutorialTable.COLUMN_DESCRICAO, PerguntasTable.COLUMN_ID };
        if (projection != null) {
            HashSet<String> requestedColumns = new HashSet<String>(Arrays.asList(projection));
            HashSet<String> availableColumns = new HashSet<String>(Arrays.asList(available));
            // check if all columns which are requested are available
            if (!availableColumns.containsAll(requestedColumns)) {
                throw new IllegalArgumentException("Unknown columns in projection");
            }
        }
    }
}


Primeiro definimos a AUTHORITY que será o path do app, para encontrar o BD, depois definimos Uris para cada tabela, e então configuramos o UriMatcher para pegar pelo ID em vez da Uri, para melhorar a velocidade. E então criamos nosso ContentProvider, os métodos são básicos como podem ver:

query(): Seria como um select, retorna um Cursor com os registros encontrados;
getPATH(): Para retornar o PATH pelo ID;
insert(): Como o nome mesmo já diz, insere registros na tabela;
delete(): Deleta registros;
update(): Atualiza os registros;
checkColumns(): esse a gente cria para verificar se a coluna existe antes de executar qualquer comando SQL, caso mude as colunas ele não vai dar erro de SQL, pois trataremos antes.

IMPORTANTE:
Após a criação do ContentProvider temos que declará-lo no AndroidManifest.XML

<provider
            android:authorities="com.caioketo.tutorial.CustomContentProvider"
            android:name=".dao.CustomContentProvider" >
</provider>

E agora sim estamos prontos para trabalhar com o BD, sempre iremos usar o ContentProvider para todas as operações, e podemos até criar um método no ContentProvider para executar um comando SQL (se nescessário) para apenas essa classe se comunicar diretamente com o BD, assim encapsulamos a comunicação.

E aqui finalizo mais um post, qualquer dúvida, sugestão, erro, etc, favor deixar comentários, e até a próxima.


terça-feira, 19 de agosto de 2014

Projetos em Pi - O Cliente [Tutorial Socket.IO + Android]

Bom, como ainda não posso começar a programar o servidor, por problemas técnicos, começarei a modelar o cliente, irei faze-lo para android, utilizando Socket.IO para comunicação.
Segue um tutorial de como utilizar o Socket.IO no android.

Tutorial Socket.IO Android

Para começar recomendo baixar e configurar o Ant para compilar o socket.io-java-client.
1- Baixe o ant-current-bin.zip (http://archive.apache.org/dist/ant/).
2- Extraia em um diretório qualquer.
3- Adicione ANT_HOME nas variáveis do sistema com o caminho para o diretório no qual vocês extraiu.

Pronto, o Ant está configurado, agora vamos baixar o socket.io-java-client. (https://github.com/Gottox/socket.io-java-client)
Na wiki do github tem bem explicadinho, qualquer dúvida coloque aqui nos comentários que eu explico melhor.

Após compilado o soket.io-java-client, você terá na pasta /jar um arquivo chamado socketio.jar, copie esse arquivo para a pasta lib do seu projeto, no android studio clique no jar com o botão direito e depois clique em "Add as library..." para adicionar ao seu projeto.
Pronto, agora estamos com tudo configurado, vamos começar a programar.

No meu projeto (que depois irei liberar no github), eu criei 2 classes para facilitar, mas você pode utilizar uma só.

Teremos a classe que fará a conexão que eu chamei de Client:


public class Client {
    private final String SERVER = "http://ip-do-servidor:porta/";
    private IOParser parser = new IOParser();
    public void Connect() {
        try {
            SocketIO socket = new SocketIO(SERVER);
            socket.connect(parser);
        }
        catch (Exception ex) {

        }
    }
}


E a outra classe que será responsável por interpretar as mensagens comunicações:

public class IOParser implements IOCallback {
    @Override
    public void onDisconnect() {

    }

    @Override
    public void onConnect() {

    }

    @Override
    public void onMessage(String s, IOAcknowledge ioAcknowledge) {

    }

    @Override
    public void onMessage(JSONObject jsonObject, IOAcknowledge ioAcknowledge) {

    }

    @Override
    public void on(String s, IOAcknowledge ioAcknowledge, Object... objects) {

    }

    @Override
    public void onError(SocketIOException e) {

    }
}

Aqui eu nem comecei a implementar, mas dá pra ter uma idéia fácil de como fazer isso.
Na classe Client você poderá adicionar depois métodos para envio de mensagens e deixar a IOParser apenas para recepção.
Bom isso é o básico, conforme vou vendo alguma coisa nova irei colocando os tutoriais aqui.

Obrigado e até a próxima!



Projetos em Pi - Reunindo funções

Bom dia para todos,
Desde a última postagem, resolvi que irei usar o LCD TFT que comprei, porém tenho que comprar mais 1 chip para poder testar tudo direitinho, enquanto não consigo comprá-lo, criei esse post para reunir as funções que colocarei nesse projeto.

O Básico

Esse projeto será para colocar o raspberry pi em um carro, com alimentação por bateria + recarregamento por painéis solares, então toda função deverá ser útil para essa situação.

As Funções

Até agora já reuni algumas funções que desejo colocar, entre elas:
-Music Player (tocar músicas que estarão em bibliotecas dentro do RPi, selecionando-as pelo celular ou tablet, conectando a saída de audio do RPi ao som do carro, e ainda sincronizando as bibliotecas com a wifi de casa, caso o alcance da wifi chegue na rua).
-Video Player (mesma coisa que as músicas, porém com vídeos, irei conectar um monitor HDMI 15'' no RPi, que também será alimentado pela mesma bateria)
-GPS Module (um módulo de GPS para navegação, através do Google Maps, ou Waze (se conseguir), pela tela TFT)
-Emuladores (colocarei emuladores de MAME, SNES, etc, para jogar pelo monitor, quando não assistindo vídeos)
-Controles PS3 (conectar os controles do ps3 para poder jogar os emuladores)

**A bateria que estou usando no projeto é uma bateria 12V de nobreak, coloquei uma bateria separada para não prejudicar (descarregar) a bateria do automóvel)

Pedido

Agora peço à todos que tiverem idéias para mais funções, colocá-las nos comentários e irei atualizando esse post com todas as funções que achar possíveis e úteis.


Obrigado à todos, e até a próxima.

sexta-feira, 15 de agosto de 2014

Projetos em Pi - Em busca da Tela

Bom dia,
Descobri que o chip que eu tenho é errado para o trabalho de ligar o monitor TFT, porém, tenho um tablet velho jogado, abri ele, tirei o LCD + Touchscreen.
Agora estou no trabalho de pesquisa para tentar conectar esse LCD no raspberry pi, se eu consegui, vai ficar até melhor do que eu esperava. Porém como o tablet é chinês, é difícil achar os datasheets do lcd, ou seja, vou ter muito trabalho para achar, e pode ser que nem ache.
Bom por hoje é só, vou continuar na pesquisa, caso encontre algo, atualizarei o blog aqui.
Até lá.

quarta-feira, 13 de agosto de 2014

Projetos em Pi - O Recomeço

Bom, após ficar um bom tempo parado, decidi hoje retornar aos meus projetos em pi.
Primeiramente, irei testar um LCD que eu comprei, (LCD + Touch), se alguém quiser verificar o modelo e schemas que vou usar estão aqui (http://marks-space.com/2013/05/23/raspberry-pi-with-a-3-2-tft-with-touch-control/).
Caso consiga colocar para funcionar o LCD com o touch, irei criar uma classe em python para controlá-lo através do socket.io, ou seja, fazer a comunicação entre a UI (botões e touch) e os componentes do projeto (músicas, controle, sensores, etc).
Hoje à tarde postarei mais atualizações, e espero não ter que parar novamente, agora vamos até o final.
Até a próxima.

sexta-feira, 23 de maio de 2014

[BerryBoot] Como bootar seu raspberry pi pela USB

Bom dia,
Hoje irei ensinar a configurar o BerryBoot, um programa que gerencia o boot no raspberry pi, e assim poderemos colocar para "bootar" pelo usb (HD ext, PenDrive, etc), lembrando que isso não tira a necessidade do cartão SD.


Instalando o BerryBoot

Primeiro iremos baixar o BerryBoot.
Para instalá-lo só precisamos extrair o zip para o cartão SD (formatado em FAT32). Apenas copie os arquivos de dentro do zip e cole no SD (simples não?).

Configurando o BerryBoot




Se seu RaspberryPi estiver conectado ele já pega toda a configuração automática. Clique em OK para continuar.



Selecione a unidade na qual será instalado o sistema operacional e clique em formatar..




Selecione o sistem (Raspbian, OpenELEC, etc)



O SO será baixado da internet e instalado automaticamente.



Esse é o menu de boot do BerryBoot, você pode adicionar mais SO se quiser, lembre-se de deixar o que você mais usa como default, assim ele irá bootar automaticamente se não for pressionada nenhuma tecla.



Pronto, assim finalizamos a instalação e configuração do BerryBoot, agora seu Raspbian (ou outro SO) roda direto do seu pen drive, ou hd ext.

Fonte: http://www.berryterminal.com/doku.php/berryboot

quarta-feira, 9 de abril de 2014

Habilitando cloud9 IDE no raspberry pi

Boa tarde,
Hoje consegui habilitar cloud9 IDE no raspberry pi, para quem não sabe o que é cloud9 IDE (https://c9.io/), ela é basicamente uma WebIDE para programar pelo browser.
Vou colocar passo a passo como instalá-la no raspberry pi.

sudo npm install -g sm
git clone https://github.com/ajaxorg/cloud9.git cloud9
npm install treehugger
npm install formidable
npm install gnu-tools
npm install xmldom
cd cloud9
sudo sm install

Após isso, ela já estará instalada, porém precisamos alterar algumas configurações para funcionar corretamente.
Edite o arquivo "bin/cloud9.sh" e antes da linha "*) echo "Unkown OS"" adicione as seguintes linhas:

Linux*raspberrypi*) echo "Linux raspberrypi ARM
    node server.js "$@" -a x-www-browser
;;

Depois edite o arquivo "configs/default.js" e altere a variável host para:
var host = argv.l || "0.0.0.0";

Agora já está tudo correto para iniciar o serviço digite:
bin/cloud9.sh -w ~/PastaDoSeuProjeto

Agora é só acessá-lo pelo navegador em
http://ipdoseuraspberrypi:3131

Por hoje é só.
Até a próxima!

segunda-feira, 31 de março de 2014

Projetos em Pi - Problemas com SD-Card

Bom Dia,
Descobri esses dias, que o SD-Card tem problemas de funcionalidades, quando roda um sistema nele, problemas com leituras/gravações que ocasionam corrupções nos arquivos do sistema.
Agora estou precisando de um HD externo para poder rodar o sistema nele, se alguém quiser ajudar a comprar, pode fazer doações pelo paypal ao lado.
Obrigado à todos.
Até a próxima

sexta-feira, 28 de março de 2014

Projetos em Pi - O Recomeço

Bom Dia,
Estou recomeçando o projeto, com novas funções. Ainda tenho que esperar chegar os componentes que encomendei pelo aliexpress (www.aliexpress.com) e assim que estiver tudo comigo, começarei a postar aqui todos os passos e os códigos.
Também criarei um repositório público no github aonde colocarei o projeto completo, junto com as fotos dos hardwares, e esquemas.
Por enquanto é só, espero ter novidades em breve.

quinta-feira, 19 de dezembro de 2013

Série Projetos em Pi - Power Control

Venho informar que em breve começarei uma nova fase da série "Projetos em Pi".
Já encomendei os componentes necessários para começar a melhor parte de um projeto de automação residencial (Relês), ou seja, controlar luzes, e outros equipamentos, pelo pi.
Assim que começar colocarei aqui os passos para deixar tudo funcionando.

quinta-feira, 29 de agosto de 2013

Série Projetos em Pi

Boa tarde,
Hoje venho anunciar que a primeira fase da Série Projetos em Pi está concluída.
Pelo html posso controlar minha multi-canal (GVT), tocar músicas (pelo artista ou playlists), e agora conclui um programa para baixar músicas pelo youtube e upar para o Google Music.
Para aqueles que tiverem mais idéias que eu possa implementar, favor colocar nos comentários, estarei estudando mais funções para implementar na fase 2 do projeto, vale lembrar que o controle de luzes ainda não foi iniciado por não ter como comprar os relês. (aceito doações :-P)
Vale lembrar também que o projeto encontra-se no github: https://github.com/caioketo/KController
Acredito que hoje consiga upar o programa para download.
Por enquanto é isso ae, em breve postarei as próximas fases do projeto.
Até lá!

terça-feira, 27 de agosto de 2013

Série Projetos em Pi - Aumenta o Som Parte I

O projeto do controle está funcionando, só precisando adicionar funções, então, parti para outro projeto, tocar músicas pelo pi, controlado pelo celular, com a mesma interface do controle.
Para esse projeto, achei o melhor jeito sendo usar o google music, existe uma API (unnoficial) para streama as músicas.
Neste momento já estou listando os artistas, ao selecionar um artista, lista os albums, e depois as músicas, fora que já consegui carregar as playlists. Agora só falta fazer tocar a musica selecionada.
Em breve postarei no github os códigos para tal, e na parte de hardware, é só ligar o som na saída de audio do pi.

sábado, 24 de agosto de 2013

Série Projetos em Pi - O Controle - Parte VI

Finalmente o controle de canais pelo smartphone (ou pc), já está funcionando.
Eu me baseei em outro projeto que achei em um blog, muito bom: https://github.com/slimjim777/web-irsend
Porém, eu alterei para funcionar do jeito que eu preciso, ou seja, não terá que selecionar dispositivo, e não terá um controle.
Por enquanto já está funcionando a lista de canais, peguei na internet uma lista de canais em JSON da GVT, e fiz o programa em python importar essa lista, e ao clicar em um item da lista, o pi, envia pelo IR, os botões referentes ao canal, por exemplo, o Universal Chanel (43) o pi vai enviar, KEY_4, KEY_3, KEY_OK, e com isso vai mudar o canal.
Agora preciso colocar o controle de volume, e outros controles que surgirão..
O código do meu programa em python para fazer isso está no github também: https://github.com/caioketo/KController
Conforme eu vá adicionando recursos, vou colocar lá no repositório e também criarei posts aqui explicando cada recurso.

quinta-feira, 22 de agosto de 2013

Série Projetos em Pi - O Controle - Parte V

Agora iremos aprender a ligar o transmissor e testá-lo.

Conectando o transmissor

O problema com o transmissor, é que o GPIO do pi vai mandar um sinal muito fraco, etnão precisaremos de um transistor para funcionar. Esse é o schematic que eu uso, sem o R2, que seria uma resistência muito baixa (que não é nescessária)

Os componentes são (R1=220ohm, Q1=BC547 transistor), 3.3V liga junto com o receptor, no pi, e o GROUND também.

Testando o transmissor

Para testá-lo, teremos que ter uma configuração básica no LIRC, como eu tinha o receptor já conectado, eu usei ele para criar a configuração, mas existe várias configurações pela internet.
Para criar uma configuração, mapeando o controle remoto, você terá que rodar:


Primeiro paramos o lirc
sudo /etc/init.d/lirc stop
Usamos o irrecord para gravar os comandos
irrecord -d /dev/lirc0 ~/lircd.conf
Fazemos um backup do lircd.conf original
sudo mv /etc/lirc/lircd.conf /etc/lirc/lircd_original.conf
agora copiamos o nosso
sudo cp ~/lircd.conf /etc/lirc/lircd.conf
Iniciamos o lirc novamente
sudo /etc/init.d/lirc start


Agora dentro do arquivo lircd.conf terá uma linha que será o nome do dispositivo, que estará assim

Begin remote
    name ~/lircd.conf


Vamos modificar o name para o nome do controle que usamos, assim ficará mais fácil de enviar os sinais.
Para enviar os sinais é só usar o comando:

irsend SEND_ONCE nome KEY_POWER

(nome=nome do controle) KEY_POWER será a tecla que você mapeou no irrecord. Pronto, ele terá que funcionar corretamente, lembrando novamente de checar tudo caso não funcione.

quarta-feira, 21 de agosto de 2013

Série Projetos em Pi - O Controle - Parte IV

Hoje irei ensinar como fazer o receptor e transmissor IR funcionarem no raspberry pi.

Instalando o LIRC no raspberry pi

Instalar o LIRC no raspberry pi é bem fácil, mais do que eu pensava.
Primeiro temos que baixar o LIRC:

sudo apt-get install lirc

Após ele baixar e instalar, precisamos configurar 2 arquivos antes de começar a usar o LIRC.
O primeiro é para o pi carregar o módulo do lirc, então, iremos no arquivo /etc/modules e adicionaremos as seguintes linhas:

lirc_dev
lirc_rpi gpio_in_pin=18 gpio_out_pin=17

Lembrando de trocar o 18 e 17 pelos pinos nos quais você colocou o receptor (out) e transmissor (in).
Depois disso precisamos configurar o hardware do LIRC, então iremos no arquivo /etc/lirc/hardware.conf e deixaremos assim:

######################################################## 
# /etc/lirc/hardware.conf 
# 
# Arguments which will be used when launching lircd 
LIRCD_ARGS="--uinput" 
# Don't start lircmd even if there seems to be a good config file 
# START_LIRCMD=false 
# Don't start irexec, even if a good config file seems to exist. 
# START_IREXEC=false 
# Try to load appropriate kernel modules 
LOAD_MODULES=true 
# Run "lircd --driver=help" for a list of supported drivers. 
DRIVER="default" 
# usually /dev/lirc0 is the correct setting for systems using udev DEVICE="/dev/lirc0" 
MODULES="lirc_rpi" 
# Default configuration files for your hardware if any 
LIRCD_CONF="" 
LIRCMD_CONF="" 
########################################################

Agora precisamos reiniciar o LIRC para que ele assuma as alterações:

sudo /etc/init.d/lirc stop
sudo /etc/init.d/lirc start

Pronto, agora nosso LIRC está instalado e configurado.

Conectando o receptor

Essa é a parte mais fácil, o receptor possui 3 pernas, 1- VCC, 2- GROUND, 3- VOUT (lembre-se de procurar o datasheet do seu modelo para pegar a ordem correta das pernas). O VCC iremos ligar no 3.3V do pi, o GROUND ligaremos no GROUND do pi, e o VOUT, nós iremos ligar no gpio que foi configurado.
Mais ou menos assim:


Testando o receptor

Para testar o receptor é bem simples, primeiro vamos parar o LIRC, e depois iremos mandar um comando para ele escrever no terminal tudo que ele ler.

sudo /etc/init.d/lirc stop mode2 -d /dev/lirc0

Agora aponte o controle remoto para o receptor, e aperte alguns botões, você deverá ver no seu terminal algo assim:

space 16300 
pulse 95 
space 28794 
pulse 80 
space 19395 
pulse 83 
space 402351 
pulse 135 
space 7085 
pulse 85 
space 2903

Se não aparecer nada provavelmente você configurou alguma coisa errada, verifique todas as configurações novamente. Para mapear os botões do controle, você pode usar o comando "irrecord" desse jeito

irrecord -d /dev/lirc0 ~/lircd.conf

No próximo post irei explicar como conectar o transmissor IR, para deixar tudo 100%.
Até lá!

terça-feira, 20 de agosto de 2013

Série Projetos em Pi - O Controle - Parte III

Após muito sofrimento com a configuração, finalmente consegui fazer o básico funcionar.
Hoje montei a "interface" de transmissão de IR, testei uns botões do controle (mapeei, e transmiti para a TV) tudo funcionou direitinho.
Agora vem a parte legal, programar um jeito fácil de utilizar, através do celular (android), e provavelmente HTML5, irei adicionar as funções que acho mais útil.
No próximo post, irei explicar direitinho como fazer tudo funcionar, desde os esquemas eletrônicos, até as configurações, tudo detalhadamente para quem quiser replicar em casa.
Bom, só vim atualizar o andamento do projeto, até a próxima!