Sugestão para portabilidade de libs.

[Red Neck Guy]

Uma forma que tenho adotado, usando um exemplo tosco:


ARQUIVO C

Código: Selecionar todos

/***********************************************************************************
*      Includes
***********************************************************************************/
#include "HT1381.H"
#include "HT1381_targetWrapper.h"

/***********************************************************************************
*   Definições
***********************************************************************************/
#define COMAND_BYTE                                   0x80

#define READ                                          0x01
#define WRITE                                         0x00

#define SECONDS_REGISTER                              (0x00)<<1
#define MINUTES_REGISTER                              (0x01)<<1
#define HOURS_REGISTER                                (0x02)<<1

#define DATE_REGISTER                                 (0x03)<<1
#define MONTH_REGISTER                                (0x04)<<1
#define DAY_REGISTER                                  (0x05)<<1
#define YEAR_REGISTER                                 (0x06)<<1

#define PROTECTION_REGISTER                           (0x07)<<1
/***********************************************************************************
*      Variaveis locais
***********************************************************************************/


/***********************************************************************************
*      Funções locais
***********************************************************************************/
unsigned char dec_to_bcd(unsigned char decimal);
unsigned char bcd_to_dec(unsigned char bcd);
void HT1381_writeByte(unsigned char data);
void HT1381_readByte(unsigned char *pData);
void HT1381_initChip(void);
void HT1381_writeRegister(unsigned char registrador,unsigned char valor);
unsigned char HT1381_readRegister(unsigned char registrador);
/***********************************************************************************
*      Implementação
***********************************************************************************/

/***********************************************************************************
*   Descrição     :   Inicialização do módulo
*   Parametros    :   nenhum
*   Retorno       :   nenhum
***********************************************************************************/
void HT1381_init(void){
 
   INIT_PINS_RTC();   
   
   IO_PIN_OUTPUT();
   
   CLR_SCLK();
   CLR_RESET_PIN();
   CLR_IO_PIN();
   
   HT1381_initChip();
}
/***********************************************************************************
*  Descrição   : CONVERTE UM VALOR DECIMAL PARA BCD
*  Parametros  : DECIMAL(UNSIGNED CHAR)
*  Retorno     : UNSIGNED CHAR
***********************************************************************************/
unsigned char dec_to_bcd(unsigned char decimal){
  unsigned char valor_temp;

  valor_temp = (16*((unsigned char) decimal/10)) + ((unsigned char) decimal%10);
   return valor_temp;
}
/***********************************************************************************
*  Descrição   : CONVERTE UM VALOR BCD PARA DECIMAL
*  Parametros  : BCD(UNSIGNED CHAR)
*  Retorno     : UNSIGNED CHAR
***********************************************************************************/
unsigned char bcd_to_dec(unsigned char bcd){
  unsigned char  dado, aux;

  aux = bcd;
  dado = bcd & 0x0F;
  aux >>= 4;
  aux &= 0x0F;
  dado += (aux*10);
  return dado;
} 
/***********************************************************************************
*   Descrição     :   Escreve um byte no relógio
*   Parametros    :   (unsigned char) valor
*   Retorno       :   nenhum
***********************************************************************************/
void HT1381_writeByte(unsigned char data){
  unsigned char i;
       
  for(i=0;i<8;i++){         
     if(data&0x01) SET_IO_PIN();
     else CLR_IO_PIN();         
     SET_SCLK();     
     __asm NOP;
     __asm NOP;
     CLR_SCLK();     
     data>>=1;
  }     
}
/***********************************************************************************
*   Descrição     :   Lê um byte do relógio
*   Parametros    :   (unsigned*)pData)
*   Retorno       :   nenhum
***********************************************************************************/
void HT1381_readByte(unsigned char *pData){
  unsigned char i,mask=1;
 
  *pData = 0x00; 
  for(i=0;i<8;i++){     
    CLR_SCLK();       
    __asm NOP;
    __asm NOP;
    SET_SCLK();   
    __asm NOP;
    __asm NOP;   
    if(GET_IO_PIN())
      *pData |= mask;     
    mask<<=1;
  }     
  CLR_SCLK();
}
/***********************************************************************************
*   Descrição     :   Escreve um byte em um dos registradores
*   Parametros    :   (unsigned char) Registrador
*                     (unsigned char) valor
*   Retorno       :   nenhum
***********************************************************************************/
void HT1381_writeRegister(unsigned char registrador,unsigned char valor){
 
  IO_PIN_OUTPUT(); // Configura o pino de dados como saída 
  SET_RESET_PIN(); // da máquina de estados do chip
   
  HT1381_writeByte(COMAND_BYTE | registrador | WRITE);//Envia o byte de controle
  HT1381_writeByte(dec_to_bcd(valor));//envia o dado
 
  CLR_RESET_PIN();   // Apaga o pino de reset
}
/***********************************************************************************
*   Descrição     :   Lê um byte de um dos registradores
*   Parametros    :   (unsigned char) Registrador
*   Retorno       :   (unsigned char) lido
***********************************************************************************/
unsigned char HT1381_readRegister(unsigned char registrador){
  unsigned char temp;
 
  IO_PIN_OUTPUT();// Configura o pino de dados como saída 
  SET_RESET_PIN();
   
  HT1381_writeByte(COMAND_BYTE | registrador | READ);//Envia o byte de controle
 
  IO_PIN_INPUT();//Configura o pino de dados como entrada
  __asm NOP;
  __asm NOP;
 
  HT1381_readByte(&temp);// Lê o byte do registrador solicitado
   
  CLR_RESET_PIN();// Apaga o pino de reset
 
  return bcd_to_dec(temp);//Antes de retornar converte o registrador para decimal.
}
/***********************************************************************************
*   Descrição     :   Atualiza o relógio
*   Parametros    :   (unsigned char) hora,minuto,segundo
*   Retorno       :   nenhum
***********************************************************************************/
void HT1381_ajustaRelogio(unsigned char hora,unsigned char minuto,unsigned char segundos){

  HT1381_writeRegister(HOURS_REGISTER,hora);     
  HT1381_writeRegister(MINUTES_REGISTER,minuto);
  HT1381_writeRegister(SECONDS_REGISTER,segundos); 
}
/*********************************************************************************** 
*  Descrição     :  Lê os valores do relógio
*  Parametros    :  (unsigned char*) Hora,
*                   (unsigned char*) minuto
*                   (unsigned char*) segundo
*  Retorno       :  nenhum
***********************************************************************************/
void HT1381_leRelogio(unsigned char *hora,unsigned char *minuto,unsigned char *segundo){

  *hora = HT1381_readRegister(HOURS_REGISTER);
  *minuto = HT1381_readRegister(MINUTES_REGISTER);       
  *segundo = HT1381_readRegister(SECONDS_REGISTER); 
}
/*********************************************************************************** 
*  Descrição    : Ajusta o calendário
*  Parametros   : (unsigned char) dia
*                 (unsigned char) mes
*                 (unsigned char) ano
*  Retorno      : (nenhum)
***********************************************************************************/
void HT1381_ajustaCalendario(unsigned char dia,unsigned char mes,unsigned char ano){
 
  HT1381_writeRegister(DATE_REGISTER,dia); 
  HT1381_writeRegister(MONTH_REGISTER,mes); 
  HT1381_writeRegister(YEAR_REGISTER,ano);   
}
/*********************************************************************************** 
*   Descrição   :   Lê os registradores do calendário
*   Parametros  :   (unsigned char*)dia,
*                   (unsigned char*)mes,
*                   (unsigned char*)ano
*   Retorno     :   nenhum
***********************************************************************************/
void HT1381_leCalendario(unsigned char *dia,unsigned char *mes,unsigned char *ano){

  *dia = HT1381_readRegister(DATE_REGISTER);
  *mes = HT1381_readRegister(MONTH_REGISTER);
  *ano = HT1381_readRegister(YEAR_REGISTER);
}
/*********************************************************************************** 
*   Descrição   :   Inicializa o Chip
*   Parametros  :   nenhum
*   Retorno     :   nenhum
***********************************************************************************/
void HT1381_initChip(void){
   
  HT1381_writeRegister(PROTECTION_REGISTER,0x00);
}
/*********************************************************************************** 
*   Fim do arquivo
***********************************************************************************/


ARQUIVO H

Código: Selecionar todos


void HT1381_init(void);

void HT1381_ajustaRelogio(unsigned char hora,unsigned char minuto,unsigned char segundos);
void HT1381_leRelogio(unsigned char *hora,unsigned char *minuto,unsigned char *segundo);

void HT1381_ajustaCalendario(unsigned char dia,unsigned char mes,unsigned char ano);
void HT1381_leCalendario(unsigned char *dia,unsigned char *mes,unsigned char *ano);



ARQUIVO TARGET WRAPPER

Código: Selecionar todos

#include <MC9S08AC32.H>

#define SCLK_PIN_DIR        PTFDD_PTFDD6
#define RESET_PIN_DIR       PTDDD_PTDDD7
#define IO_PIN_DIR          PTFDD_PTFDD7

#define SCLK_PIN            PTFD_PTFD6
#define RESET_PIN           PTDD_PTDD7
#define IO_PIN              PTFD_PTFD7

#define SET_SCLK()          SCLK_PIN = 1
#define CLR_SCLK()          SCLK_PIN = 0

#define SET_RESET_PIN()     RESET_PIN = 1
#define CLR_RESET_PIN()     RESET_PIN = 0

#define SET_IO_PIN()        IO_PIN = 1
#define CLR_IO_PIN()        IO_PIN = 0
#define GET_IO_PIN()        IO_PIN
#define IO_PIN_INPUT()      IO_PIN_DIR = 0
#define IO_PIN_OUTPUT()     IO_PIN_DIR = 1

#define INIT_PINS_RTC()     {SCLK_PIN_DIR = 1;\
                             IO_PIN_DIR = 1;\
                             RESET_PIN_DIR =1;}
                             
extern void SYSTICK_delay(unsigned int delay);                             
#define DELAY(X)           SYSTICK_delay(X);



[Red Neck Guy]

Ficou muito texto lá dentro pra explicar...
A idéia que utilizo é codificar a parte que é dependente do mcu dentro do arquivo targetwrapper.h. Dessa forma para cada nova plataforma só altero aquele arquivo.

[joao]

Ola Aquino,

Aqui a gente faz assim:
Nós temos o Core que é um pedaço de código que é plataforma independente.
E temos os portings que são os pedaços de código dependentes.

o core sempre chama as mesmas funçoes no porting. Ou seja, isso quer dizer que os Headers são os mesmos, mas os .cpp são diferentes.
uma estrutura do nosso projeto é:

Código: Selecionar todos

Core
 |--Core_File_A.cpp
 |--Core_File_A.h
 |--Core_File_B.cpp
 |--Core_File_B.h
 |--D_Common_include
     |--Porting_File_C.h
     |--Porting_File_D.h
 |--D_Android
     |--Porting_File_C.cpp
     |--Porting_File_D.cpp
 |--D_Symbian
     |--Porting_File_C.cpp
     |--Porting_File_D.cpp
 |--D_Windows Mobile
     |--Porting_File_C.cpp
     |--Porting_File_D.cpp

Na hora de compilar para Android, a gente inclui a pasta do android apenas. Dai não vai ter problema de Conflito de arquivo.
Todas as funcoes dos Common headers tem que ser implementadas nos diretorios propostos.

Está funcionando bem para nós por enquanto.

PS: Eu trabalho com celulares ou seja, apenas SW, nada de HW.

[]'s

[helton]

só uma dúvida, talvez nada a haver com o post, mas ....

O android é linux, e teoricamente aceita o gcc, g++, etc...

porém a google fornece um SDK em Java para desenvolvimento de aplicativos...

João, tem algum site, livro ou dica onde procurar informações sobre a utilização de C/C++ no Android ?

att

[joao]

Hey Helton,

Desculpa a demora, mas mesmo assim vou responder, vai que alguem ainda precise disso...

Em Android, você tem que programar em Java. Não existe suporte a programas C++.
O que existe e foi o que eu utilizei era o JNI.
JNI é Java Native interface. E dai vc pode programar em C++.
Como funciona é + - assim:
O seu programa tem que ser em JAVA. O JAva chama o JNI que por sua vez dá suporte ao POSIX(e apenas isso).
Dai, dependendo do que vc quer, o seu JNI pode chamar funcoes em java para ter full suporte das funcionalidades.
Por exemplo: Para mostrar algo na tela, nao rola em JNI porque nao tem lib para isso. Vc precisa ter chamadas JAVA no seu JNI para poder desenhar na tela.

Entao o JNI nao serve para nada?!?!?!? Dai depende. No nosso caso, a gente tem um parte do código inteira em POSI C++ que é plataforma independente. Entao, este codigo pode ser reaproveitado no android e apenas as chamdas especificas para funcionalidades do Android a gente chama no JAVA, usando como interface de "conversa" o JNI.

Procure por: JNI android
e você irá achar varias explicaçoes sobre isso.

[]'s