Introdução ao avr-gcc usando o AvrStudio [Mais timers/mood light]

[artur36]

Se queres largar a IDE do Arduino precisas de aprender C no mínimo. Tens muita informação e não é difícil encontrar o Kernighan&Ritchie ("The C Programming Language"), a bíblia do C escrita pelos autores da linguagem.

Se te safares em inglês existe  um livro chamado beginning C for Arduino. Se quiseres em português tens linguagem C de Luís damas, ambos disponíveis nas "lojas" do costume.

[migvalsan]

Basicamente tens de chamar a função "para dentro de uma variável".
Qualquer coisa do género:

Variável= função();

Na função que deste em cima a última linha vai retornar o valor de st para a variável que definiste ao chamar a função.

Ou então usas na função uma variável que declaras-te como geral e depois no restante código podes testar directamente essa variável (funciona mas não é o correcto/ideal).

Isto é C geral, não sei se é exactamente assim que o avr-gcc funciona, mas deve ser minimamente parecido.

Errado, isso não vai funcionar porque não estás a passar o apontador da string como parâmetro para a função.

Com o código mostrado precisas de ter um array de chars definido:

Código: [Seleccione]

char s[10];E para atribuir o valor basta usar o nome do array como parâmetro:

Código: [Seleccione]

UART_GetString(s);
Trabalhar com apontadores é um bocado diferente, estudem sobre o assunto.

Código: [Seleccione]

char * UART_GetString(char *st)

// string is returned when <enter> key is pressed
{
 char c;
 byte count=0;
 while ((count<80) && ((c = UART_Read()) != '\r'))
 {
 UART_Write(c); // echo char back to console
 st[count++] = c; // add char to string
 }
 st[count]='\0'; // add NULL termination
 return st;
}
neste caso o maximo da string vai ser 80 caracteres certo?
cumps

[migvalsan]

Se queres largar a IDE do Arduino precisas de aprender C no mínimo. Tens muita informação e não é difícil encontrar o Kernighan&Ritchie ("The C Programming Language"), a bíblia do C escrita pelos autores da linguagem.

Se te safares em inglês existe  um livro chamado beginning C for Arduino. Se quiseres em português tens linguagem C de Luís damas, ambos disponíveis nas "lojas" do costume.

sim até me safo em inglês
vou pesquisar isso obrigado

[artur36]

Jm-Araújo peço desculpa se disse alguma asneira, o meu C é muito básico e orientado para PIC.
Mas era a maneira que eu ia usar se fosse para um int por exemplo (arrays nunca trabalhei). Penso que a solução que apresentas-te é para enviar uma string e ele quer receber, acho eu.


Edit: rasurei as dicas que dei, aparentemente estão erradas e não quero induzir em erro ninguém.

[jm_araujo]

Código: [Seleccione]

char * UART_GetString(char *st)

// string is returned when <enter> key is pressed
{
 char c;
 byte count=0;
 while ((count<80) && ((c = UART_Read()) != '\r'))
 {
 UART_Write(c); // echo char back to console
 st[count++] = c; // add char to string
 }
 st[count]='\0'; // add NULL termination
 return st;
}
neste caso o maximo da string vai ser 80 caracteres certo?
cumps

Nesse cado precisas de passar um array de 81 caracteres, porque a contagem começa a count=0, o loop sai com count=80 e essa posição é escrita com o NULL.

Jm-Araújo peço desculpa se disse alguma asneira, o meu C é muito básico e orientado para PIC.
Mas era a maneira que eu ia usar se fosse para um int por exemplo (arrays nunca trabalhei). Penso que a solução que apresentas-te é para enviar uma string e ele quer receber, acho eu.

Não, está certo como mostrei. Para iniciantes a cena toda de arrays e apontadores é um bocado confusa, e não tenho muito jeito para professor.
Mete o seguinte exemplo neste site: http://www.compileonline.com/compile_c_online.php

Código: [Seleccione]

#include <stdio.h>

char* teste(char* str)
{
    int i;
    for (i=0;i<5;i++)
        str[i]='a'+i;
    str[i]='\0';
    return str;
}


main()
{
    char s[16]="Lusorobotica";
    printf("Valor Inicial: %s\n",s);

    teste(s);
    printf("Valor Final: %s\n",s);
}
(feito à pressa, podia estar mais bonito)

Como podes ver chamo a função "teste" da mesma maneira que disse atrás, e a string é alterada. O que estás a passar como parâmetro é um apontador (tem o asterisco) para a posição de memória onde está o array. Em C não consegues alterar uma variável passada como parâmetro para uma função, mas se for um apontador, nada impede que alteres a memória para onde aponta. Como disse, é um pouco confuso e os livros fazem melhor o trabalho que eu

[artur36]

Como podes ver chamo a função "teste" da mesma maneira que disse atrás, e a string é alterada. O que estás a passar como parâmetro é um apontador (tem o asterisco) para a posição de memória onde está o array. Em C não consegues alterar uma variável passada como parâmetro para uma função, mas se for um apontador, nada impede que alteres a memória para onde aponta. Como disse, é um pouco confuso e os livros fazem melhor o trabalho que eu

Agora já liguei o PC (estava a ver através do tapatalk).

Vi o teu exemplo e percebi (gostei da abordagem do a+i para avançar para o caracter seguinte, nunca me tinha lembrado de tal coisa).
No entanto pelo que eu percebi da pergunta original o  migvalsan quer receber caracteres da uart, no exemplo de código que ele apresentou é lida a uart e gravado na string ST que é retornada no fim da função certo?

Se ele chamar a função assim:

Código: [Seleccione]

char valor[];
valor[]= UART_GetString();

Não vai ficar com o valor de ST na string valor?

P.S.: É provável que esteja errado, mas isto era o que eu faria, também quero aprender a forma correcta.

[jm_araujo]

Código: [Seleccione]

char valor[];
valor[]= UART_GetString();
Não vai ficar com o valor de ST na string valor?

Nope. A função retorna um apontador para st, que é o mesmo do parâmetro inicial. Essa atribuição dá erro, não é possível manipular arrays dessa maneira em C. Só podes atribuir valor aos seus membros (tens de ter número entre os parênteses retos) e não alterar o array (que funciona como um apontador estático).

Tem de ser:

Código: [Seleccione]

char valor[16]; //ou o tamanho do buffer que quiser
UART_GetString(valor);

Usa a meu exemplo para testares e aprenderes. Faz de conta que a função "teste" é a UART_GetString, fazem a mesma coisa: alteram uma string.

[migvalsan]

Código: [Seleccione]

char * UART_GetString(char *st)

// string is returned when <enter> key is pressed
{
 char c;
 byte count=0;
 while ((count<80) && ((c = UART_Read()) != '\r'))
 {
 UART_Write(c); // echo char back to console
 st[count++] = c; // add char to string
 }
 st[count]='\0'; // add NULL termination
 return st;
}
neste caso o maximo da string vai ser 80 caracteres certo?
cumps

Nesse cado precisas de passar um array de 81 caracteres, porque a contagem começa a count=0, o loop sai com count=80 e essa posição é escrita com o NULL.

Jm-Araújo peço desculpa se disse alguma asneira, o meu C é muito básico e orientado para PIC.
Mas era a maneira que eu ia usar se fosse para um int por exemplo (arrays nunca trabalhei). Penso que a solução que apresentas-te é para enviar uma string e ele quer receber, acho eu.

Não, está certo como mostrei. Para iniciantes a cena toda de arrays e apontadores é um bocado confusa, e não tenho muito jeito para professor.
Mete o seguinte exemplo neste site: http://www.compileonline.com/compile_c_online.php

Código: [Seleccione]

#include <stdio.h>

char* teste(char* str)
{
    int i;
    for (i=0;i<5;i++)
        str[i]='a'+i;
    str[i]='\0';
    return str;
}


main()
{
    char s[16]="Lusorobotica";
    printf("Valor Inicial: %s\n",s);

    teste(s);
    printf("Valor Final: %s\n",s);
}
(feito à pressa, podia estar mais bonito)

Como podes ver chamo a função "teste" da mesma maneira que disse atrás, e a string é alterada. O que estás a passar como parâmetro é um apontador (tem o asterisco) para a posição de memória onde está o array. Em C não consegues alterar uma variável passada como parâmetro para uma função, mas se for um apontador, nada impede que alteres a memória para onde aponta. Como disse, é um pouco confuso e os livros fazem melhor o trabalho que eu

fixe, testei o teu exemplo e já percebi e já consegui por o meu codigo a funcionar.

mas como está sou obrigado a enviar uma string com 81 caracteres se não não sai do ciclo while... como é que posso por o codigo de maneira a poder enviar uma string do tamanho que entender e o programa guardar apenas o que envio na string?

cumps

[jm_araujo]

Nesse código a string acaba com um enter (o " != '\r' ")
Podes definir outro carater como fim da string a ler, como por exemplo um espaço ou ponto e virgula...

[migvalsan]

Mas como está caso eu não introduza 81 caracteres não sai do ciclo while..
Mas já tentei tirar a parte "(count<80)&& "  e não funciona também..
O que queria era Não ter de ser obrigado a introduzir um certo número de caracteres.

Cumprimentos

[jm_araujo]

Mostra aí o teu código completo.

[migvalsan]

Mostra aí o teu código completo.

Código: [Seleccione]

#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>

#define BAUDRATE 9600
#define BAUD_PRESCALLER (((F_CPU / (BAUDRATE * 16UL))) - 1)

//declaração das nossas funções
void USART_init(void);
unsigned char USART_receive(void);
void USART_send( unsigned char data);
void USART_putstring(char* StringPtr);
char * UART_GetString(char *st);

char String[]="Olá mundo!!!"; //String[] que dizer que é um array, mas ao colocar-mos o texto entre "" indicamos ao compilador que é uma string e ele coloca automáticamente o terminador null e temos assim uma string de texto usavel

int main(void){
USART_init();  //Inicializar a usart
    char strr[200];
while(1){  //Loop infinito



USART_putstring(String); //Passamos a nossa string á função que a escreve via serial

UART_GetString(strr);

USART_putstring(strr);

_delay_ms(1000);  //E a cada 5s re-enviamos o texto
}

return 0;
}

void USART_init(void){

UBRR0H = (uint8_t)(BAUD_PRESCALLER>>8);
UBRR0L = (uint8_t)(BAUD_PRESCALLER);
UCSR0B = (1<<RXEN0)|(1<<TXEN0);
UCSR0C = (3<<UCSZ00);
UCSR0A &= ~(1<<U2X0);
}

unsigned char USART_receive(void){

while(!(UCSR0A & (1<<RXC0)));
return UDR0;

}

void USART_send( unsigned char data){

while(!(UCSR0A & (1<<UDRE0)));
UDR0 = data;

}

void USART_putstring(char* StringPtr){

while(*StringPtr != 0x00){
USART_send(*StringPtr);
StringPtr++;}

}

char * UART_GetString(char *st)

// string is returned when <enter> key is pressed
{
char c;
int count = 0;
while ((count<80) && ((c = USART_receive()) != '\r'))
{
//UART_Write(c); // echo char back to console
st[count++] = c; // add char to string
}
st[count]='\0'; // add NULL termination

return st;
}


[migvalsan]

já descobri qual era o problema... o terminal que estava a usar não enviava o "enter" por isso é que a função ficava presa no while 
bem, obrigado senso jm_araujo e artur36 pela ajuda

ja agora podem me indicar um bom terminal?

cumprimentos

Miguel

[jm_araujo]

Eu gosto do Bray Terminal: https://sites.google.com/site/terminalbpp/
Mas a última versão no site tem alguns problemas se enviares muita coisa de rajada e tiver a vista Hex, dec e/ou bin ligada.
A última versão "escondida" já se porta melhorzinho: https://sites.google.com/site/terminalbpp/Terminal20140703.zip?attredirects=0

[Kristey]

Agora que voltei aqui, vi que algumas das imagens estão down.
Queres ajuda para voltar a por tudo direitinho?