Monitor de Hardware com Arduino

Olá caro leitor, sempre gostei de painéis de monitoramento é algo belo de se ver para um nerd como eu, e a ideia de monitorar meu hardware via algum tipo de painel é extremamente sedutora, além do que meu kit de Arduino guardado em uma gaveta sem estar sendo utilizado em nada estava me incomodando, com essas motivações tive esta ideia.

 

Monitor de Hardware com Arduino

 

Eu utilizo o conky como monitor de hardware, este é extremamente flexível, fiz um build dele desabilitando o outuput no X deixando e sobrescrevendo a saída para console, este por sua vez permite escrever a saída do console diretamente para um arquivo o que possibilitou escrever a saída na porta serial (/dev/ttyACM0) usada  para comunicação com o Arduíno, abaixo segue a ligação feita no Arduíno

 

Ligação com o Arduino

 

Ligacao-LCD-HD44780-Backlight-Azul_bb

Código fonte do programa para rodar no Arduíno

//Carrega a biblioteca LiquidCrystal
#include <LiquidCrystal.h>

//Define os pinos que serão utilizados para ligação ao display
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // initialize the serial communications:
  Serial.begin(9600);
}

void loop() {
  char caractere;
  String linha1 = "";
  String linha2 = "";
  byte linha = 1;

  if (Serial.available()) {
    while(Serial.available() > 0) {

      caractere = Serial.read();

      if (caractere != '\n'){
        if (linha == 1)
          linha1.concat(caractere);
        if (linha == 2)
          linha2.concat(caractere);
      }
      else
      {
        if (linha == 1)
          linha = 2;
      }
      delay(10);
    }

    // clear the screen
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(linha1);
    lcd.setCursor(0, 1);
    lcd.print(linha2);
    delay(2000);
  }
}

Arquivo de configuração do conky (.conky_no_x)

 

out_to_x no
cpu_avg_samples 2
net_avg_samples 2
no_buffers yes
out_to_console no
#out_to_stdeerr no
extra_newline no
update_interval 3.0
#uppercase yes
#user_space none
overwrite_file /dev/ttyACM0

TEXT
CPU $cpu% MEM $memperc%
D ${downspeedf eth0}k U ${upspeedf eth0}k

 

para rodar é necessário o comando

conky -c .conky_no_x</pre>

Para finalizar devo acoplar esse aparato dentro do gabinete, este já vai exigir habilidades artesanais as quais não possuo.

 

Posted in Uncategorized Tagged with:

Thread Pool em C++ usando SDL2

Depois que fiz o processamento do conjunto de mandelbrot, fiquei com a ideia de fazer o mesmo  código executando em mais de uma thread de modo a alcançar maior desempenho; e se possível renderizar o conjunto a mais de 24 quadros por segundo (FPS), depois de muita pesquisa descobri que a melhor forma de trabalhar com Threads era o utilizando-se de um Thread Pool, essa técnica é muito eficiente pois evita o overhead de criação de threads quando se tem um número grande de tarefas a serem executadas, pesquisei por alguma biblioteca Open Source mas todas que eu encontrei usavam a pthread (posix thread), e no caso estou no Windows usando CodeBlocks e MinGW, a solução foi implementar o pattern usando a biblioteca SDL2.
Thread Pool Pattern

Thread Pool Pattern

Thread Pool Pattern fonte Wikipedia [1]

ThreadPool.h

<code>#ifndef THREADPOOL_H
#define THREADPOOL_H
#include
typedef enum TaskState {
Initialized,
Running,
Finished
};

class Task
{
public:

virtual void *DoWork() = 0;

};

class ThreadPool
{
public:
/** Default constructor */
ThreadPool();

/** Initialize with number of Threads */
void init(int _numThreads);

/** Destroy the pool */
void destroy();

/** Add task to Queque */
void addWork(Task *task);

/** Default destructor */
virtual ~ThreadPool();
int numThreads;
std::queue&lt;Task*&gt; workQueque;
};

extern ThreadPool poolThread;
#endif // THREADPOOL_H

ThreadPool.cpp

#include "ThreadPool.h"
#include "SDL.h"
#include "SDL_thread.h"
#include "SDL_timer.h"
#include <stdio.h>
#define MAX_THREADS 64

//Pointer to Threads
SDL_Thread *threads[MAX_THREADS];

//Mutex for trhead safe sync
SDL_mutex *quequeMutex;
SDL_mutex *workerMutex;
SDL_mutex *mutexBarrier;

//Signals
SDL_cond *condHaveWork;
SDL_cond *condBarrier;

extern ThreadPool poolThread;

//This main function, while thread pool alive (detroy not called)
//this function monitor task queque, to process it

void *worker(void *param)
{
    while (1)
    {

        //Try to get Task
        Task *task = NULL;
        SDL_LockMutex(quequeMutex);
        //have task in queque
        int num = poolThread.workQueque.size();
        if (num > 0)
        {

            task = poolThread.workQueque.front();
            poolThread.workQueque.pop();
        }
        else
        {

        }
        SDL_UnlockMutex(quequeMutex);

        //if have task, run it
        if (task != NULL)
        {
            task->DoWork();
        }
         //if no have job thread in IDLE
        if (num == 0)
        {

            SDL_LockMutex(workerMutex);
            SDL_CondWait(condHaveWork,workerMutex);
            SDL_UnlockMutex(workerMutex);
        }
    }
}
ThreadPool::ThreadPool()
{
    //ctor

}

void ThreadPool::init(int _numThreads)
{
    //setup mutex
    quequeMutex = SDL_CreateMutex();
    workerMutex = SDL_CreateMutex();
    condHaveWork = SDL_CreateCond();
    mutexBarrier = SDL_CreateMutex();
    condBarrier = SDL_CreateCond();

    //setup number of threads
    numThreads = _numThreads;

    //initialize all threads
    for(int i = 0; i < numThreads; i++)
    {
        char threadName[128];
        sprintf(threadName,"Thread %d",i);
        //Create thread
        threads[i] = SDL_CreateThread(worker,threadName,&poolThread);
        if (NULL == threads[i])
        {
            printf ("Falha ao Criar thread \n");
        }

    }
}

//Destroy the thread pool
void ThreadPool::destroy()
{
    for (int i = 0; i < numThreads; i++)
    {
        //Kill threads
        if (threads[i] != NULL)
            SDL_DetachThread(threads[i]);
    }

    //Destroy Mutex and Signals
    SDL_DestroyMutex(quequeMutex);
    SDL_DestroyMutex(workerMutex);
    SDL_DestroyMutex(mutexBarrier);
    SDL_DestroyCond(condBarrier);
    SDL_DestroyCond(condHaveWork);
}

//Enqueque work to pool
void ThreadPool::addWork(Task *task)
{
    //Enqueque work
    SDL_LockMutex(quequeMutex);
    workQueque.push(task);
    int size = workQueque.size();
    SDL_UnlockMutex(quequeMutex);

    //Emit signal of new work
    SDL_LockMutex(workerMutex);
    SDL_CondSignal(condHaveWork);
    SDL_UnlockMutex(workerMutex);

}

ThreadPool::~ThreadPool()
{

}

Um ponto de atenção é com a linha onde está declarado o ThreadPool

extern ThreadPool poolThread;

Isso acontece pelo fato de eu não ter deixado a função void *worker (void *params), dentro da classe o contexto em que eu estou usando é bem definido então não achei necessário usar mais que um ThreadPool.

Toda tarefa a ser executado no Thread Pool, deve ser uma classe que herdada da classe Task .

//Task of compute mandelbrot slice
//this is sent to ThreadPool
class SliceComputeTask : Task
{
public:
    double step; // is ScreenHeight / NumberOfCores
    unsigned index; //Actual "Slice"
    int state; //Used for wait all threads done

    virtual void *DoWork()
    {
        state = Running;

        //Offset of slice
        double y1 = step*index;
        for(unsigned y=y1; y<y1+step; ++y)
        {
            double c_im = MaxIm - y*Im_factor;
            for(unsigned x=0; x<SCREEN_WIDTH; ++x)
            {
                double c_re = MinRe + x*Re_factor;

                double Z_re = c_re, Z_im = c_im;
                bool isInside = true;
                //offset of pixelBuffer
                const unsigned offset = ( SCREEN_WIDTH * 4 * y ) + x * 4;
                //offset of Color Palette
                unsigned pOffset = 0;
                unsigned n;

                for(n=0; n<MaxIterations; ++n)
                {
                    double Z_re2 = Z_re*Z_re, Z_im2 = Z_im*Z_im;

                    if(Z_re2 + Z_im2 > 4)
                    {
                        isInside = false;
                        break;
                    }
                    else
                    {
                        //Draw Pixel According with color table
                        pixelArray[offset] = colorPal[n];
                        pixelArray[offset + 1] = colorPal[n+1];
                        pixelArray[offset + 2] = colorPal[n+2];
                        pixelArray[offset + 3] = SDL_ALPHA_OPAQUE;

                    }
                    Z_im = 2*Z_re*Z_im + c_im;
                    Z_re = Z_re2 - Z_im2 + c_re;
                }
                if(isInside)
                {
                    //Draw pixel
                    pixelArray[offset] = 0;
                    pixelArray[offset + 1] = 255;
                    pixelArray[offset + 2] = 255;
                    pixelArray[offset + 3] = SDL_ALPHA_OPAQUE;

                }
            }
        }
        //Task finished
        state = Finished;

    };
};

 

Antes de ser usado o Thread Pool dever ser iniciado

    //Initialize thread Pool

    //Get CPU Count
    CPUCount = SDL_GetCPUCount();

    //initialize Threads
    poolThread.init(CPUCount);

    //allocate task's in memory
    sliceTasks = new SliceComputeTask[64];

Agora finalmente podemos enviar tarefas para o threadPool, a função draw_mandelbrot() é chamada no loop principal, eu dividi o  conjunto em fatias e cada fatia será processado por uma thread (CPUCount)

//mandelbrot main function
void draw_madelbrot()
{
    //calculate slice size
    int TaskSize = CPUCount;
    double step = SCREEN_HEIGHT / CPUCount;

    for (int i = 0; i < TaskSize; i++)
    {

        //Setup task
        sliceTasks[i].step = step;
        sliceTasks[i].index = i;
        sliceTasks[i].state = Initialized;

        //Queque task
        poolThread.addWork((Task*)&sliceTasks[i]);
    }

    //wait all task finish
    int k = 0;
    bool frameDone = false;
    while(frameDone == false)
    {
        if (k == TaskSize)
            frameDone = true;

        if (sliceTasks[k].state == Finished)
            k++;

    }

}

Resultado com 2 Threads.

Mandelbrot sendo computado com duas threads

Mandelbrot sendo computado com duas threads

Reultado com 4 Threads.

Conjunto de mandelbrot sendo computado com 4 threads

Conjunto de mandelbrot sendo computado com 4 threads

Resultado com 8 Threads (SDL_GetCPUCount())

Conjunto de mandelbrot sendo computado com oito threads.

Conjunto de mandelbrot sendo computado com oito threads.

Podemos ver um aumento do número de FPS e do uso da CPU conforme aumentamos o número de threads, a CPU só não fica em 100% pelo fato de algumas regiões do conjunto demorarem mais para serem computadas do que outras e o uso do vsync (espera de todas as thread terminarem para atualizar a tela); acredito que se eu dividir o conjunto em uma grid de 8×8, conseguiria alcançar uma taxa de mais de 24 FPS, mas isso fica para uma próxima.

O código fonte completo pode ser encontrado no github.

https://github.com/psilogroup/Mandelbrot-Mult-Thread

Espero que goste xD

 

[1] https://en.wikipedia.org/wiki/Thread_pool

Posted in C++

Template de Aplicação usando MEAN – MongoDB, Express, Angular e NodeJS

Controle de Gastos feito usando-se MEAN – MongoDB, Express, Angular e NodeJS, a construção do app surgiu da minha necessidade de controlar o dinheiro que eu sacava do banco, nunca sabia para onde este dinheiro estava indo, e sempre achei chato as app’s de controle de finanças disponíveis no mercado poís achava o processo de lançar gastos muito demorado, eu queria algo que fosse bem rápido pra lançar, hoje venho usando essa app no meu dia a dia e está sendo bem utíl pra ter uma visualisação de onde meu dinheiro está sendo gasto.

Por ser um aplicativo sem grandes complexibilidades creio que seja um ótimo ponto de partida para quem esteja querendo utilizar estas tecnologias, tenho uma arquitetura simples mas com tudo nescessário para iniciar um app, desde um API Rest feito com NodeJS, persistindo em uma database MongoDB, até o uso de autenticação por json web token usando AngularJS. Então se estiver estudando ou querendo controlar seus gastos vale a pena dar uma olhada

Aplicativo Online Link da aplicação

Arquitetura

  • API\ – Serviço NodeJS para a API REST de comunicação com o banco de
    • Database.js – Schema do banco de dados, utilizando o plugin Mongoose.
    • Repositorie.js – Arquivo que configura as rotas da API REST e faz a persistência com o banco de dados.
    • SrvOndeGastei.js – Arquivo principal do Serviço em NodeJS.
  • APP\ – Aplicação Single Page feita com AngularJS
    • app.js – arquivo principal do AngularJS com a configuração dos controles
    • controllers\ – Controles javascript
  • assets\ – Conteúdo de js e css
  • templates\ – Templates HTML (View), para uso combinado com os controles
  • Index.html – Arquivo principal do WebSite/APP

 

Projeto disponível no GitHub: https://github.com/psilogroup/OndeGastei.git

 

Posted in NodeJS

Controle de Gastos .NET MVC 4, Entity Framework 6 Code First, Bootstrap, AJAX

Aplicativo onde se pode cadastrar gastos por categoria, com as funcionalidade de exibir uma lista contendo todos os gastos dos últimos 30 dias e dois gráficos mostrando os gastos por categoria

Técnologias Utilizadas :

  • MVC 4
  • Entity Framework 6 (Code First)
  • Bootstrap
  • JQuery
  • AJAX
  • Google Chart API

Arquitetura:

Repositório:

O Repositório (RepositorioMovimentoFinanceiro), implementa a interface IRepositorioMovimentoFinanceiro, esta interface tem o contrato dos métodos Inserir, Remover, Listagem e Agrupamento, a classe MovimentoFinanceiro representa a entidade do EF 6 e finalmente a classe Contexto que contém a representação do banco de dados (DbContext)

Domínio:

O Domínio (DominioMovimentoFinanceiro), trabalha com a interface IRepositorioMovimentoFinanceiro, contendo os seguintes métodos que serão consumidos pelo Controller MVC:

  • NovoGasto (insere um novo gasto no banco de dados)
  • GastosUltimoMes (Lista todos os gastos do último mês)
  • GastosPorCatePorCategoria (Agrupa os gastos por categoria e soma o valor total para cada categoria)

UI:

A interface foi feita com base no template padrão de MVC, com a adição do Bootstrap, todos as operações de inserção e listagem são feitas de maneira assíncrona, utilizando para isso JQuery e AJAX os gráficos foram implementados com a Chart API do google.

Telas:

Inserção de Gasto

Inserir Gasto

Listagem contendo todos os gastos do mês

Analitico

Gráficos

graficos

Download: https://github.com/psilogroup/ControleGastoMVC/archive/master.zip

GitHub: git clone https://github.com/psilogroup/ControleGastoMVC.git

Posted in Uncategorized

Obtento a memória usada pelo programa em C, no linux

Agora tenho um desktop de ultima geração, um AMD FX 8320 (8×3.5Ghz) com 16 GB de memória, è estou pensando em uma maneira de justificar todo esse exagero (essa vai ser difícil); pois bem fui fazer um teste para ver quanto tempo demorava para somar um array de 10.000.000 de double’s, fiquei um tanto impressionado pois meu processador achou essa somatória no mínimo ridícula eis, a prova.

 

tempoExecucao

0.308 ms, ao menos pra mim isto é bem rápido, depois disso fiquei curioso para saber o quanto de memória estava sendo utilizada pelo programa, depois de algumas pesquisas na internet, descobri que o jeito mais confiável de fazer é através do /proc/[pid]/status, ele de ta diversas informações sobre o processo.

por exemplo, meu firefox bolinador de memória com uma aba aberta (a que estou escrevendo este post) está levando 1 GB de memória virtual, VmRSS em 260Mb (266300 Kb)

Firefox bulinador de memória

Firefox bolinador de memória

Como podem ver pelo VmSize (Memória Virtual), o FF está com 1GB (1066440 Kb).

VmSize:
Virtual memory size
This is the virtual memory usage of the entire process. It is the sum of VmLib, VmExe, VmData, and VmStk.

Googlando sobre o assunto, vi uma forma de fazer o parse deste arquivo e obter a memória utilizada pelo programa, o autor usou a função para gerar um gráfico da memória utilizada pelo programa durante sua execução, eu como simples mortal só queria exibir a memória utilizada pelo mesmo, então simplifiquei muito o que ele fez.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>


#define M_ARRAY_SIZE 10000000

double a[M_ARRAY_SIZE];
double b[M_ARRAY_SIZE];
double c[M_ARRAY_SIZE];

void print_vm_size()
{
	int len = 128;
	char *line;
	char pid_status[256];
	char *vmsize;
	FILE *f;
	vmsize = NULL;
 	line = malloc(128);
	pid_t myId = getpid();

	sprintf(pid_status,"/proc/%d/status",myId);
	printf("%s\n",pid_status);

	f = fopen(pid_status, "r");
	if (!f) return 1;

	while (!vmsize)
	{
		if (getline(&amp;line, &amp;len, f) == -1)
		{
			/* Some of the information isn't there, die */
			printf("xiii\n");
			return 1;
		}

		/* Find VmSize */
		if (!strncmp(line, "VmSize:", 7))
		{
			vmsize = strdup(&amp;line[7]);
		}
	}
	free(line);
	fclose(f);

	/* Get rid of " kB\n"*/
	len = strlen(vmsize);
	vmsize[len - 4] = 0;

	/* Output results to stderr */
	printf("VmSize: %s Kb\n",vmsize);

	free(vmsize);

	/* Success */
	return 0;

}

int main(int argc,char **argv)
{

int i = 0;
print_vm_size();
for(i = 0; i &lt; M_ARRAY_SIZE;i++)
	a[i] = 0;

for (i = 0;i &lt; M_ARRAY_SIZE;i++)
	b[i] = rand() % M_ARRAY_SIZE;

for (i = 0;i &lt; M_ARRAY_SIZE;i++)
	c[i] = a[i] + b[i];

//sleep(120);

return 0;
}

como podem ver na primeira imagem o programa utilizou 233Mb de memória (238708Kb).

Somando-se os 3 arrays de double temos:

 3*8*10000000 = 240000000
240000000 / (1024*1024) = 228Mb.

Espero que esse código lhe seja útil.

baseado no artigo: http://locklessinc.com/articles/memory_usage/

Posted in Uncategorized Tagged with:

Fractais: Mandelbrot em C++ com SDL

Final de semana sem nada pra fazer e sempre tive vontade de brincar com fractais, então depois de umas pesquisas no google portei um que tinha achado em C++ fazia o output em um arquivo .bmp, como o arquivo estava no formato errado resolvi fazer um port para  C++ e SDL desse fractal de Mandelbrot:

Sem mais comentários pois foi só um passatempo, você pode baixar o código nesse link:

https://drive.google.com/file/d/0B48ThBHnxF4UNnJ3SlpLT1U3blk/edit?usp=sharing
http://pt.wikipedia.org/wiki/Conjunto_de_Mandelbrot
http://www.vivaolinux.com.br/script/Conjunto-de-Mandelbrot-(Fractal) (src usado como base)
Abraço.

Posted in Uncategorized Tagged with:

Singleton para jogos em C++

Olá pessoal, hoje vou compartilhar minha implementação de Singleton, segundo a Wikipédia Singleton é:

Singleton é um padrão de projeto de software (do inglês Design Pattern). Este padrão garante a existência de apenas uma instância de uma classe, mantendo um ponto global de acesso ao seu objeto.

Ou seja uma maneira elegante de utilizar objetos globais aos quais só tem uma única instância, o melhor exemplo disso seria a Câmera, o nó raiz da cena, ou qualquer outro objeto que tenha acesso global.

#ifndef __SINGLETON__
#define __SINGLETON__
#include
#include "ObjectManager.h"
#include "Camera.h"
class Singleton
{
private:
Singleton() {}
public:
static Singleton *instance;
dWorldID world;
dSpaceID space;
ObjectManager rootSceneNode;
Camera rootCamera;
dJointGroupID contactGroup;
// Função-membro que retorna sempre a mesma instância do objeto
static Singleton & getInstance()
{
if (!instance) instance = new Singleton();
return *instance;
}
};

#endif // __SINGLETON__

percebam que o construtor é privado isso impede de dar new na classe e criar uma nova instância; O que mas como eu vou usar então sem dar new na classe? Resposta sempre através do método getInstance, segue o exemplo de utilização.

Singleton::getInstance().world = dWorldCreate();
dWorldSetGravity(Singleton::getInstance().world,0.0,0.0,-9.8);
Singleton::getInstance().rootSceneNode.add(object);
Singleton::getInstance().rootSceneNode.Draw();

Espero que a implementação seja útil:
Saudações.

 

Mais referência: http://pt.wikipedia.org/wiki/Singleton

Posted in Uncategorized Tagged with:

Aventuras com Texturas

shot

Estou me aventurando com as texturas, no caso das caixas de do terreno ficou até que bom, o SkyBox está com borda nas texturas e eu não consegui entender o por que.

pode baixar aqui:
Posted in Uncategorized Tagged with:

Mapeamento de malha de terreno em Vertex Buffer Object

img3

 

Para gerar o terreno criei uma malha  de vetores de n * n, cada item da matriz representa um quadrado formado por dois
trianglos, então no caso de uma matriz de 32 x 32, teremos 2.048 trianglos, 4096
vértices (x,y,z), 6.144 índices (i) e
6.144 coordenadas de textura (u,v).Este primeiro é responsável por preparar a malha de terreno, aqui é o ponto
ideal para criar montanhas e crateras através do eixo z
numIndexs = (height * width * 6);
numVecs = (height * width * 4);
vecs = new vec3d[numVecs];
texCoord = new TexCoord2[numVecs];
indexs = new dTriIndex[numVecs];
for (int y=0; y< h; y++)
for (int x=0; x< w; x++)
{
int offset = w*y+x;
vecs[offset].x = (x*scale);
vecs[offset].y = (y*scale);
vecs[offset].z = 0.0f;
}

O desenho é feito
através de um VertexBufferObject herdado
da classe Mesh as texturas também
estão armazenadas no Mesh e por
final a classe Terrain que contém as
características do terreno e a implementação dos algoritmos de carga das informações
dos vértices, texturas e índices.
Diagrama

Depois de mapeado copio os buffers para a memória do
hardware através da classe quem implementa o VBO

vbo = new VertexBufferObject();
vbo->glMode = GL_TRIANGLES;
vbo->setVertices(vecs,numVecs);
vbo->setIndexs(indexs,numIndexs);
vbo->setTexCoords(texCoord,numIndexs);
Por fim no método Draw, faço
a render do terreno.
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glTranslatef(iPosition.x,iPosition.y,iPosition.z);
//Draw Here
texture->begin();
vbo->draw();
texture->end();
glPopMatrix();
Este foi um terreno de 32×32 a ideia agora é criar terrenos de até
2048×2048, para isso vou precisar dividir o terreno em várias partes menores e
só deixar na memória as partes que estão sendo visualizadas pelo ator, além de
possibilitar multi textura é um grande desafio pela frente.
Posted in Uncategorized

Classe Servo Motor

shot

Olá pessoal, implementei uma Classe para simular um motor servo e consegui construir um triciclo com cinco servos, há também um “radar” em cima do robô que é mais um Servo, como previsto por estar utilizando a Open Dynamics Engine para física vou poder usar a engine para simulação robóticas, estou pensando em criar uma luta de robôs, implementando mais uma joint o Pistão com isso vai dar pra criar até um trator (Sempre quis um trator)

você pode ver como o robô foi montado no header R1D1.h
não preciso dizer que falta muita coisa ainda pra sair um jogo mas o trabalho continua.

você pode fazer o download no Source Forge, neste link  agora no pacote tambén tem as libs usadas é só corrigir os “path” no projedo do CodeBlocks que da pra compilar.

Link para Download 

Posted in Uncategorized Tagged with: