Como concatenar vars em c programada pic?

Question

I programar um pic 16F84A na hitech C para dirigir um LCD HD44780. Até agora eu tenho o lcd inicializado e pode escrever caracteres individuais e cordas para o LCD. Agora eu preciso fazer algo como isto:

var = 250;
lcd_write_string ( "MyVar tem valor:" + var);
de modo que o LCD deve mostrar "MyVar tem valor: 250"

Antes de tudo como eu deveria concatenar uma var e uma corda? segundo, a variável var contém um número binário de 8 bits (0-255 em decimal). Se var = 23; o número de 8 bit tem de ser dividido em dois para representar o 2 e o 3 em ASCII para, em seguida, ser mostrado pelo LCD. como posso fazer isso? Parece que eu tenho que fazer base de 10 conversões ou se árvore para dividir todos os números de 2 dígitos para ser mostrado no LCD. Existe uma maneira mais fácil de contornar isso?

Obrigado!

Answer 1

Por que você não apenas usar printf("%d", var)?

var = 250;
char *static_msg = "MyVar has value:";
char msg[sizeof(static_msg) + 4];

sprintf(msg, "%s %d", static_msg, var);
lcd_write_string(msg);

Answer 2

Supondo que o seu conjunto de ferramentas não inclui a biblioteca C padrão, ou que você quer descobrir como fazer isso mesmo, aqui é a abordagem que eu tomaria:

Declare um tampão de tantos personagens como o LCD pode exibir. Escrever sua seqüência fixa para o início desse buffer. Determinar quantos caracteres de largura variável será (há um pouco de matemática eu estou deixando aqui, mas é um exercício razoável eu acho). Usando esse comprimento, eo comprimento da corda fixa, descobrir onde em dígitos do tampão seu de número vai. Usando as mesmas construções matemáticas como antes, escrever os dígitos para esse espaço, um por um. Há um truque da linguagem C (exigido pela norma) que lhe permite descobrir o valor do caractere de um dígito decimal pela '0' + digit expressão. Com sorte, você ver como isso funciona. Finalmente, terminar o tampão no entanto os seus espera função lcd_write_string, e chamá-lo no buffer.

Como indicado por outros entrevistados, este essencialmente implementa uma pequena parte da família printf da biblioteca padrão de funções. Eu acho que vale a pena descobrir a implementação, mesmo se você pode (e deve!) Usar a biblioteca no código de produção.

Uma vez que isto cheira vagamente como lição de casa, eu não estou elaborando mais ainda. Se precisar de ajuda em pontos específicos, eu vou olhar se há atualizações para a questão.

Answer 3

Se o compilador C vem com as funções de biblioteca C padrão, então sprintf lata ser utilizado semelhante ao printf, a fim de produzir uma string.

sprintf pode ser usado para produzir uma cadeia formatada (como char*), o que poderia presumivelmente ser enviados para a função lcd_write_string.

Answer 4

O problema com sprintf () é que você não sabe quantos bytes você precisa alocar antes de chamar sprintf (). Eu costumo usar o seguinte ksprintf () como uma substituição.

typedef struct __kstring_t {
  size_t l, m;
  char *s;
} kstring_t;

int ksprintf(kstring_t *s, const char *fmt, ...)
{
  va_list ap;
  int l;
  va_start(ap, fmt);
  l = vsnprintf(s->s + s->l, s->m - s->l, fmt, ap); // not working with glibc 2.0
  va_end(ap);
  if (l + 1 > s->m - s->l) {
    s->m = s->l + l + 2;
    kroundup32(s->m);
    s->s = (char*)realloc(s->s, s->m);
    va_start(ap, fmt);
    l = vsnprintf(s->s + s->l, s->m - s->l, fmt, ap);
  }
  va_end(ap);
  s->l += l;
  return l;
}

Para usar o seguinte:

kstring_t *str = calloc(1, sizeof(kstring_t));
ksprintf(str, "%s, %d\n", aString, aInteger);
ksprintf(str, "a second line: %s\n", aString2);
free(str->s); free(s);

ksprintf () não funciona com glibc 2.0 porque vsnprintf não retorna o número de bytes na string. Você precisa dobrar repetidamente a memória em alocação. página man Linux "homem snprintf" também dá um exemplo. Em seu sistema, você deve verificar o comportamento do seu vsnprintf (), que é C99, C90 não embora.

Answer 5

Outra maneira de fazer isso seria usar lcd_write_string como um ponteiro de função e faça o seguinte:

printf(lcd_write_string,"MyVar has value: %d",var)

Isso funciona corretamente em compilador CCS Pic C, se lcd_write_string é declarado como

void lcd_write_string (char c);