Midori

Coloque o menu dentro de um loop, assim o usuário poderá escolher entre as operações durante a execução. Além disso, sugiro o uso de definições para usar no case. Segue um exemplo, #include <stdio.h>#include <stdlib.h> #define CALC_RES 1#define CALC_TEN 2#define CALC_COR 3#define SAIR 4short menu(){ short i = 0, op; const char *m[] = { "[1] Calcular resistencia\n", "[2] Calcular tensao\n", "[3] Calcular corrente\n", "[4] Sair\n", "Selecione:" }; while(i < SAIR){ printf("%s",m[i++]); } scanf("%d", &op); return op;}int main(){ int op, resultado; while((op = menu()) != SAIR){ switch(op){ case CALC_RES: resultado = 1; break; case CALC_TEN: resultado = 2; break; case CALC_COR: resultado = 3; break; default: printf("Opcao invalida\n"); exit(1); } printf("Resultado = %d\n", resultado); } return 0;}

Screen, Outra forma legal de converter, é ativando/desativando o quinto bit (considerando a 'string' de bits de 0 a n da direita para a esquerda) No exemplo do 'A', a string de bits é 1000001 e do 'a' é 1100001. Logo, para converter de A -> a, basta ativar o quinto bit. Isso pode ser feito da seguinte forma: #define MINUSCULA(ch) (((ch >= 'A') && (ch <= 'Z')) ? ch | (1<<5) : ch) Aí basta criar uma função para converter o ponteiro passado como parâmetro: void minuscula(char *str){ while(*str++ = MINUSCULA(*str));}

Use uma função para, durante a comparação, deixar todos os caracteres maiúsculos (ou minúsculos)

Recomendo que estude estrutura de dados para implementar no seu programa. É um conceito importante que qualquer programador deve conhecer. Há um tópico fixo sobre o assunto nessa seção, sugiro que dê uma olhada.

Sobre o underline me parece apenas convenção. Uma forma que o programador usou para identificar o nome dos parâmetros das definições. Sobre a linha digitalWrite... É apenas a instrução a ser executada caso o if seja verdadeiro Sobre o define, essa instrução apenas diz para o compilador substituir a definição pela instrução. E os parênteses ajudam a assegurar a ordem de precedência das operações, por exemplo: #define SERVO_INDEX(_timer,_channel) ((_timer*SERVOS_PER_TIMER) + _channel)Os parênteses serão importantes, pois pode acontecer de: SERVO_INDEX(2,3) * 4 Como há parânteses, ((2 * SERVOS_PER_TIMER) + 3) * 4, a multiplicação por 4 será feita após as operações internas.

Poste o que você tentou fazer.

Dessa forma, se fosse num csv você poderia enviar os dados com a delimitação, mas num xls não sei se é possível.

De que forma você inseriu essas informações? Usou alguma API?

Qual é a dúvida?

Acredito que removendo o espaço resolva. Outra alternativa é colocar a inserção dentro de um loop infinito, for(;{ scanf("%d",&i); if(i == -1) break; novo = (LISTA*)malloc(sizeof(LISTA)); novo->num = i; novo->prox = lista; lista = novo; }

Usei duas funções de string.h, uma para comparar e outra para contar os caracteres. Caso não seja permitido no exercício, basta implementá-las int i = 0, qtd = 0; while(maior[i] != '\0'){ if((!i) || (maior[(!i ? 1 : i) - 1] == ' ')){ int n = i, t = 0; char temp[strlen(menor)]; while(t < strlen(menor)){ temp[t] = maior[n]; t++; n++; } temp[t] = '\0'; if(!strcmp(temp, menor))qtd++; } i++; }

Também não funcionou. Vou marcar o tópico como resolvido pois tentarei fazer de outra forma. Estou estudando os códigos de outros emuladores, que usam SDL e funcionam corretamente, e vou tentar acrescentar o método usado neles. Pelo que pude perceber é necessário trabalhar com operador bit-a-bit. Valeu Screen.

Screen, Sem SDL_INIT_VIDEO meu joystick não responde aos comandos, por isso tive que adicionar. Talvez o seu esteja funcionando por causa do modelo. Testei seu último código e está acontecendo a mesma coisa que o meu segundo código: Quando o direcional deixa de ser pressionado, o valor fica sempre zero. O último código que eu postei foi o que chegou mais perto de resolver, já que ele retorna o valor correto do direcional quando ele deixa de ser pressionado. O problema agora é resolver o caso em que dois direcionais são pressionados ao mesmo tempo. Já que se durante o jogo eu pressionar RIGHT e em seguida, ao mesmo tempo, UP e soltar RIGHT o código perte o valor de RIGHT e o movimento do objeto na tela fica infinitamente para a direita, já que o código não retornará mais Release para o valor de RIGHT. Estou tentando implementar um flag, no meu último código, para guardar o valor do primeiro direcional para resolver isso, dessa forma: if(num_axis){ printf("%d, %d, %d, %d\n", num_botao, num_axis, axis_flag, axis_flag_anterior); axis_flag = num_botao;}else{ printf("%d, %d, %d, %d\n", num_botao, num_axis, axis_flag, axis_flag_anterior);} Supondo RIGHT = 50 e DOWN = 40 PRIMEIRO CASO, não há simultaneidade (está funcionando corretamente) Pressiona 50: num_botao = 50 num_axis = +/-32767 axis_flag = 0 axis_flag_anterior = 0 Solta 50: num_botao = 0 num_axis = 0 axis_flag = 50 axis_flag_anterior = 50 50, 32767, 0, 0 ------------------------ Release = 0 (CODIGO : 50) Press = 1 (CODIGO : 50) ------------------------ 0, 0, 50, 50 ------------------------ Release = 1 (CODIGO : 50) Press = 0 (CODIGO : 50) ------------------------ SEGUNDO CASO, há simultaneidade (não nestá funcionando) Pressiona 50: num_botao = 50 num_axis = +/-32767 axis_flag = 0 axis_flag_anterior = 0 Pressiona 40: num_botao = 40 num_axis = +/-32767 axis_flag = 50 axis_flag_anterior = 50 Solta 50: num_botao = 0 num_axis = 0 axis_flag = 40 <--------- isso deve ser 50 axis_flag_anterior = 50 50, 32767, 0, 0 ------------------------ Release = 0 (CODIGO : 50) Press = 1 (CODIGO : 50) ------------------------ 40, 32767, 50, 50 ------------------------ Release = 0 (CODIGO : 40) Press = 1 (CODIGO : 40) ------------------------ 0, 0, 40, 50 ------------------------ Release = 1 (CODIGO : 40) Press = 0 (CODIGO : 40) ------------------------

Screen, Com a função SDL_JoystickGetAxis não deu certo, porque ela tem o mesmo efeito de jaxis.value. Consegui saber qual botão direcional deixou de ser pressionado, adicionando uma variável que serve como flag "axis_flag". Agora o problema é tratar o caso que em, por exemplo: pressiono RIGHT e ao mesmo tempo DOWN, aí solto RIGHT. No código abaixo isso não está dando certo, pois ele está salvando DOWN por útimo. Então tenho que criar uma outra flag para guardar o primeiro direcional pressionado. #include <SDL/SDL_joystick.h>#include <SDL/SDL.h>int main(){ int num_botao, num_axis, flag = 0, axis_flag = 0, axis_flag_anterior = 0; SDL_Event evento; SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK); SDL_Joystick *joy = SDL_JoystickOpen(0); while(1){ int release = 0, press = 0; // Loop de evento. while(SDL_PollEvent(&evento)){ // Retorna o código do botão pressionado num_botao = evento.jbutton.button; // Verificar o tipo de direcional (se é left, right, up, down) // 32767 para down - right // -32767 para up - left num_axis = evento.jaxis.value; if(num_axis < 0 && num_botao) num_botao = 20; // up if(num_axis < 0 && !num_botao) num_botao = 30; // left if(num_axis > 0 && num_botao) num_botao = 40; // down if(num_axis > 0 && !num_botao) num_botao = 50; // right // Coloquei esse flag pois o programa, // fica enviado 'evento.jbutton.button' automaticamente nos 12 primeiros loops if(flag++ > 12){ if(!axis_flag_anterior) axis_flag_anterior = axis_flag; if(num_axis){ axis_flag = num_botao; }else{ // Flag para tentar tratar o caso em que // dois botões direcionais são pressionados ao mesmo tempo /* if(axis_flag_anterior != axis_flag) if(num_botao && !axis_flag){ axis_flag_anterior = axis_flag; } if(!num_botao && !num_axis){ axis_flag = axis_flag_anterior; } */} // verifica que tipo de evento ocorreu printf("\n------------------------\n"); switch(evento.type){ // Se for evento do direcional case SDL_JOYAXISMOTION:{ if(num_axis){ //printf("direcional (FOI PRESSIONADO): codigo = %d\n", num_botao); press = 1; }else{ num_botao = axis_flag; //printf("direcional (DEIXOU DE SER PRESSIONADO): codigo = %d\n", num_botao); release = 1; } break; } case SDL_JOYBUTTONDOWN:{ //printf("botao (FOI PRESSIONADO): codigo = %d\n", num_botao); press = 1; if(num_botao == 6){ exit(0); } break; } case SDL_JOYBUTTONUP:{ release = 1; //printf("botao (DEIXOU DE SER PRESSIONADO): codigo = %d\n", num_botao); break; } } printf("Release = %d (CODIGO : %d) \n", release, num_botao); printf("Press = %d (CODIGO : %d) \n", press, num_botao); printf("------------------------\n"); } } } return 0;}

Oi Screen, Obrigado por responder. Essa função não resolve porque é usada para o programador ativar/desativar o loop de eventos. Ela não retorna o tipo de evento que ocorreu. Estou tentando fazer dessa forma: int main(){ int num_botao, num_axis, flag = 0; SDL_Event evento; SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK); SDL_Joystick *joy = SDL_JoystickOpen(0); while(1){ int release = 0, press = 0; // Loop de evento. while(SDL_PollEvent(&evento)){ // Retorna o código do botão pressionado num_botao = evento.jbutton.button; // Verificar o tipo de direcional (se é left, right, up, down) // 32767 para down - right // -32767 para up - left num_axis = evento.jaxis.value; // Coloquei esse flag pois o programa, // fica enviado 'evento.jbutton.button' automaticamente nos primeiros loops if(flag++ > 12){ printf("AXIS ATUAL = %d\n", num_axis); // verifica que tipo de evento ocorreu printf("\n------------------------\n"); switch(evento.type){ // Se for evento do direcional case SDL_JOYAXISMOTION:{ if(num_axis){ printf("direcional (FOI PRESSIONADO): codigo = %d\n", num_botao); press = 1; }else{ printf("direcional (DEIXOU DE SER PRESSIONADO): codigo = %d\n", num_botao); release = 1; } break; } case SDL_JOYBUTTONDOWN:{ printf("botao (FOI PRESSIONADO): codigo = %d\n", num_botao); press = 1; if(num_botao == 6){ exit(0); } break; } case SDL_JOYBUTTONUP:{ release = 1; printf("botao (DEIXOU DE SER PRESSIONADO): codigo = %d\n", num_botao); break; } } printf("Release = %d (CODIGO : %d) \n", release, num_botao); printf("Press = %d (CODIGO : %d) \n", press, num_botao); printf("------------------------\n"); } } } return 0;} Veja que no caso de JOYBUTTON, é possível verificar qual botão foi pressionado ou deixou de ser pressionado. Quando ocorre SDL_JOYBUTTONDOWN ou SDL_JOYBUTTONUP, o printf retorna o numero do botao. O problema acontece no direcional, pois a biblioteca entende que em "evento.jbutton.button" quando ocorre UP ou DOWN, o evento é 1; E quando ocorre LEFT ou RIGHT o evento é 0. Por isso é necessário verificar o evento "evento.jaxis.value": Se o valor for 32767 então é DOWN ou RIGHT; Se for -32767 É UP ou LEFT. Ou seja, LEFT = evento.jaxis.value -32767 e evento.jbutton.button = 0 RIGHT = evento.jaxis.value 32767 e evento.jbutton.button = 0 UP = evento.jaxis.value -32767 e evento.jbutton.button = 1 DOWN = evento.jaxis.value 32767 e evento.jbutton.button = 1 Até aí tudo bem, basta verificar os valores de "evento.jaxis.value" quando o direcional é pressionado para saber a direção. O problema é quando o direcional deixa de ser pressionado, pois "evento.jaxis.value" fica sempre 0.

Pessoal, Compilei o código fonte de um emulador que faz uso da biblioteca SDL. Acontece que ele é um port do Dingux e não reconhece o direcional (axis) do meu joystick USB. Ele só reconhece os eventos do botão do joystick e do teclado. Estou tentando adicionar suporte ao direcional e esbarrei no problema do programa entender o evento keyup do direcional (ou seja, do momento em que ele para de ser pressionado). Veja esse trecho do código original: #if defined(GP2X_MODE) || defined(WIZ_MODE) Event = SDLEvent.jbutton.button; if (SDLEvent.type==SDL_JOYBUTTONDOWN) ButtonPress = 1; else if (SDLEvent.type==SDL_JOYBUTTONUP) ButtonRelease = 1;#else Event=((SDL_KeyboardEvent*)(&SDLEvent))->keysym.scancode; if (SDLEvent.type==SDL_KEYDOWN) { ButtonPress = 1; } else if (SDLEvent.type==SDL_KEYUP) { ButtonRelease = 1; }#endif O problema é que no caso do direcional, não descobri uma forma de fazer a verificação de quando o direcional deixa de ser pressionado (KEYUP). Alguém conhece alguma ideia de como resolver isso? Eu queria fazer algo nesse sentido: Event = SDLEvent.jbutton.button; if ( (SDLEvent.type==SDL_JOYBUTTONDOWN) || (SDLEvent.type==SDL_DIRECIONALDOWN) ) ButtonPress = 1; else if ( (SDLEvent.type==SDL_JOYBUTTONUP) || (SDLEvent.type==SDL_DIRECIONALUP) )ButtonRelease = 1; Ou então fazer com que o programa entenda o direcional como button para ele ter os mesmos eventos. Acredito que essa seria a melhor forma.

Estou usando o PI apenas para emulação. Para quem curte, sugiro que instale a imagem do projeto Retropie pois já vem com os emuladores instalados e a configuração é bem fácil.

No MAME tentei poucos jogos dessa época. Não consegui rodar nenhum Mortal Kombat, mas Street Fighter 2, KOF98 e Samurai Shodown rodaram legal. Então eu acho que essa versão deve ter boa compatibilidade com jogos da Capcom e SNK.

Vou ver se adquiro um daqueles que já vem com adesivo. valeu!

PC Engine, Atari 2600, Playstation e os consoles da geração 8/16 bits da Sega e Nintendo. A emulação está ótima e como estou usando uma TV de tubo, fica melhor ainda.

Retroemulação = emulação de consoles (Master System, Super Nintendo, etc) ou computadores antigos.

Pessoal, Estou usando o RPI para retroemulação e aumentei o clock para 900Mhz Alguém sabe dizer se há algum problema deixar essa frenquencia sem usar dissipadores? Já faz alguns dias que estou usando o PI assim e não tive nenhum problema até agora. De vez enquando verifico a temperatura e fica por volta de 48 graus.

Sugiro que seja criada da a função primo, apenas para retornar 1 ou 0. Feito isso, basta testar dentro de um contador: if(primo(n)). Acredito que fica bem mais simples e legível

Se for no modo console, veja a documentação do seu compilador. Mas se for um aplicativo windows você deve definir se será em "c puro", programando diretamente com as API dos windows, ou em algum framework (tipo MFC, OWL, etc)

Poste o que você já fez