Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicitÓ e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Test colloquio di lavoro
Forum - C/C++ - Test colloquio di lavoro

Pagine: [ 1 2 3 ] Precedente | Prossimo
Avatar
pocho183 (Normal User)
Rookie


Messaggi: 30
Iscritto: 22/02/2013

Segnala al moderatore
Postato alle 20:01
Martedý, 01/12/2015
Questo topic Ŕ stato chiuso dal moderatore

Buonasera, volevo chiedervi un aiuto su un programma in C, allego il file e il codice.
Non riesco ad arrivare alla soluzione, volevo chiedervi se qualcuno di voi potrebbe darmi
qualche consiglio. E' un test che devo consegnare venerdi mattina, per un'azienda.

Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <iostream> //system pause
  3.  
  4. typedef struct{
  5.                 char DIO_PA_8[8];// [8] perchŔ la piu lunga Ŕ STD_HIGH
  6.         char DIO_PA_9[8];
  7.  
  8. }
  9. dio_level_t;
  10.  
  11. void Start_Display(int n)
  12. {
  13.         switch(n)
  14.         {
  15.         case 0:
  16.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  17.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  18.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  19.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  20.                 Dio_WriteChannel(DIO_PA_4, STD_HIGH);
  21.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  22.                 Dio_WriteChannel(DIO_PA_6, STD_LOW);
  23.                 break;
  24.         case 1:
  25.                 Dio_WriteChannel(DIO_PA_0, STD_LOW);
  26.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  27.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  28.                 Dio_WriteChannel(DIO_PA_3, STD_LOW);
  29.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  30.                 Dio_WriteChannel(DIO_PA_5, STD_LOW);
  31.                 Dio_WriteChannel(DIO_PA_6, STD_LOW);
  32.                 break;
  33.         case 2:
  34.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  35.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  36.                 Dio_WriteChannel(DIO_PA_2, STD_LOW);
  37.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  38.                 Dio_WriteChannel(DIO_PA_4, STD_HIGH);
  39.                 Dio_WriteChannel(DIO_PA_5, STD_LOW);
  40.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  41.                 break;
  42.         case 3:
  43.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  44.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  45.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  46.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  47.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  48.                 Dio_WriteChannel(DIO_PA_5, STD_LOW);
  49.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  50.                 break;
  51.         case 4:
  52.                 Dio_WriteChannel(DIO_PA_0, STD_LOW);
  53.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  54.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  55.                 Dio_WriteChannel(DIO_PA_3, STD_LOW);
  56.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  57.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  58.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  59.                 break;
  60.         case 5:
  61.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  62.                 Dio_WriteChannel(DIO_PA_1, STD_LOW);
  63.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  64.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  65.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  66.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  67.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  68.                 break;
  69.         case 6:
  70.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  71.                 Dio_WriteChannel(DIO_PA_1, STD_LOW);
  72.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  73.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  74.                 Dio_WriteChannel(DIO_PA_4, STD_HIGH);
  75.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  76.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  77.                 break;
  78.         case 7:
  79.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  80.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  81.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  82.                 Dio_WriteChannel(DIO_PA_3, STD_LOW);
  83.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  84.                 Dio_WriteChannel(DIO_PA_5, STD_LOW);
  85.                 Dio_WriteChannel(DIO_PA_6, STD_LOW);
  86.                 break;
  87.         case 8:
  88.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  89.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  90.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  91.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  92.                 Dio_WriteChannel(DIO_PA_4, STD_HIGH);
  93.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  94.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  95.                 break;
  96.         case 9:
  97.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  98.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  99.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  100.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  101.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  102.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  103.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  104.                 break;
  105.                 }
  106.         };
  107.  
  108. int main()
  109. {
  110.         dio_level_t Dio_ReadChannel();
  111.         static uint32_t delayMs= 1000; // che significa static uint32_t??????
  112.         char inputSeq[] = ("3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489");
  113.         char Time[]="22:11:08";
  114.         int i;
  115.         int value;
  116.         i=sizeof(inputSeq)/sizeof(char);
  117.         //printf("%d\n",i);
  118.         while(1){
  119.                 for(int x=0; x<i; x++){
  120.                 value=inputSeq[x];
  121.                 Start_Display(value);
  122.                 if (inputSeq[x++]== "."){
  123.                         if(Dio_ReadChannel(DIO_PA_8)=="STD_LOW"){
  124.                                 Dio_WriteChannel(DIO_PA_8, STD_HIGH);
  125.                         }
  126.                         else{
  127.                                 Dio_WriteChannel(DIO_PA_8, STD_HIGH);
  128.                         }
  129.                 else{ Dio_WriteChannel(DIO_PA_8, STD_LOW);
  130.                 }
  131.                 }
  132.                 x--;
  133.                 void OS_Wait(uint32_t delayMs);
  134.                 }
  135.         }
  136.                 //OS_GetActualTime();
  137.         //}
  138.     printf("This is a native C program.\n");
  139.         system("pause");
  140.     return 0;
  141. }


Ultima modifica effettuata da pocho183 il 01/12/2015 alle 20:05
PM
Avatar
nessuno (Normal User)
Guru^2


Messaggi: 5475
Iscritto: 03/01/2010

Segnala al moderatore
Postato alle 20:14
Martedý, 01/12/2015
Ma scusa, qual Ŕ il problema ??

Se non spieghi cosa dovrebbe fare il programma e cosa non va, come si fa a rispondere?

Scusa poi, ma se l'azienda ti chiede qualcosa e tu non hai il forum per aiutarti, cosa fai?


Ricorda che nessuno Ŕ obbligato a risponderti e che nessuno Ŕ perfetto ...
PM
Avatar
pocho183 (Normal User)
Rookie


Messaggi: 30
Iscritto: 22/02/2013

Segnala al moderatore
Postato alle 20:42
Martedý, 01/12/2015
Mi servirebbe un'idea su come implementare un algoritmo che:
riceva in ingresso questa stringa
char inputSeq[] = ("3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489");

e stampi su 6 display a 7 segmenti i valori in forma,sequenziale; tipo:
3
3.
3.1
3.14
3.141
3.1415
3.14159 una volta accessi tutti e sei i display, inizia lo shift
141592 ecc


Al post precedente avevo caricato l'allegato, ma non appare.

PM
Avatar
lumo (Member)
Expert


Messaggi: 416
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 20:52
Martedý, 01/12/2015
Se vuoi puoi dare alla azienda i miei contatti, io so farlo.
Pagano bene?

Ultima modifica effettuata da lumo il 01/12/2015 alle 20:52
PM
Avatar
nessuno (Normal User)
Guru^2


Messaggi: 5475
Iscritto: 03/01/2010

Segnala al moderatore
Postato alle 21:34
Martedý, 01/12/2015
Testo quotato

Postato originariamente da lumo:

Se vuoi puoi dare alla azienda i miei contatti, io so farlo.
Pagano bene?



Bella risposta anche se un po' cattivella ... :-)

In effetti, se non sai fare questo semplice codice, mi dispiace ma non credo potrai restarci molto in azienda.

A meno che questo non sia un semplice esercizio scolastico che tu vuoi farti risolvere dal forum ... potresti anche dirlo senza problemi ...


Ricorda che nessuno Ŕ obbligato a risponderti e che nessuno Ŕ perfetto ...
PM
Avatar
pocho183 (Normal User)
Rookie


Messaggi: 30
Iscritto: 22/02/2013

Segnala al moderatore
Postato alle 22:02
Martedý, 01/12/2015
sono riuscito ad implementarlo, per˛ ho problemi a far accendere la virgola.
Come ho fatto adesso Ŕ valido solo per numeri senza virgola e a me serve verificare il funzionamento su numeri con virgola.

Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <iostream> //system pause
  3.  
  4. typedef struct{
  5.                 char DIO_PA_8[8];// [8] perchŔ la piu lunga Ŕ STD_HIGH
  6.         char DIO_PA_9[8];
  7.  
  8. }
  9. dio_level_t;
  10.  
  11. void Start_Display(int n)
  12. {
  13.         switch(n)
  14.         {
  15.         case 0:
  16.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  17.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  18.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  19.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  20.                 Dio_WriteChannel(DIO_PA_4, STD_HIGH);
  21.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  22.                 Dio_WriteChannel(DIO_PA_6, STD_LOW);
  23.                 break;
  24.         case 1:
  25.                 Dio_WriteChannel(DIO_PA_0, STD_LOW);
  26.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  27.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  28.                 Dio_WriteChannel(DIO_PA_3, STD_LOW);
  29.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  30.                 Dio_WriteChannel(DIO_PA_5, STD_LOW);
  31.                 Dio_WriteChannel(DIO_PA_6, STD_LOW);
  32.                 break;
  33.         case 2:
  34.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  35.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  36.                 Dio_WriteChannel(DIO_PA_2, STD_LOW);
  37.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  38.                 Dio_WriteChannel(DIO_PA_4, STD_HIGH);
  39.                 Dio_WriteChannel(DIO_PA_5, STD_LOW);
  40.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  41.                 break;
  42.         case 3:
  43.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  44.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  45.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  46.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  47.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  48.                 Dio_WriteChannel(DIO_PA_5, STD_LOW);
  49.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  50.                 break;
  51.         case 4:
  52.                 Dio_WriteChannel(DIO_PA_0, STD_LOW);
  53.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  54.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  55.                 Dio_WriteChannel(DIO_PA_3, STD_LOW);
  56.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  57.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  58.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  59.                 break;
  60.         case 5:
  61.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  62.                 Dio_WriteChannel(DIO_PA_1, STD_LOW);
  63.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  64.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  65.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  66.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  67.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  68.                 break;
  69.         case 6:
  70.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  71.                 Dio_WriteChannel(DIO_PA_1, STD_LOW);
  72.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  73.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  74.                 Dio_WriteChannel(DIO_PA_4, STD_HIGH);
  75.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  76.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  77.                 break;
  78.         case 7:
  79.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  80.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  81.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  82.                 Dio_WriteChannel(DIO_PA_3, STD_LOW);
  83.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  84.                 Dio_WriteChannel(DIO_PA_5, STD_LOW);
  85.                 Dio_WriteChannel(DIO_PA_6, STD_LOW);
  86.                 break;
  87.         case 8:
  88.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  89.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  90.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  91.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  92.                 Dio_WriteChannel(DIO_PA_4, STD_HIGH);
  93.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  94.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  95.                 break;
  96.         case 9:
  97.                 Dio_WriteChannel(DIO_PA_0, STD_HIGH);
  98.                 Dio_WriteChannel(DIO_PA_1, STD_HIGH);
  99.                 Dio_WriteChannel(DIO_PA_2, STD_HIGH);
  100.                 Dio_WriteChannel(DIO_PA_3, STD_HIGH);
  101.                 Dio_WriteChannel(DIO_PA_4, STD_LOW);
  102.                 Dio_WriteChannel(DIO_PA_5, STD_HIGH);
  103.                 Dio_WriteChannel(DIO_PA_6, STD_HIGH);
  104.                 break;
  105.                 }
  106.         };
  107.  
  108. int main()
  109. {
  110.         dio_level_t Dio_ReadChannel();
  111.         static uint32_t delayMs= 1000; // che significa static uint32_t??????
  112.         char inputSeq[] = ("3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489");
  113.         char Time[]="22:11:08";
  114.         int i;
  115.         int value;
  116.         int z=6;
  117.         i=sizeof(inputSeq)/sizeof(char);
  118.         //printf("%d\n",i);
  119.         while(1){
  120.                 for(int x=0; x<i; x++){
  121.                         if(z=6){
  122.                                 Dio_WriteChannel(DIO_PA_14,STD_HIGH);
  123.                                 value=inputSeq[x];
  124.                                 Start_Display(value);
  125.                         }
  126.                         if(z=5){
  127.                                 Dio_WriteChannel(DIO_PA_13,STD_HIGH);
  128.                                 value=inputSeq[x-1];
  129.                                 Start_Display(value);
  130.                                 Dio_WriteChannel(DIO_PA_14,STD_HIGH);
  131.                                 value=inputSeq[x];
  132.                                 Start_Display(value);
  133.                         }
  134.                         if(z=4){
  135.                                 Dio_WriteChannel(DIO_PA_12,STD_HIGH);
  136.                                 value=inputSeq[x-2];
  137.                                 Start_Display(value);
  138.                                 Dio_WriteChannel(DIO_PA_13,STD_HIGH);
  139.                                 value=inputSeq[x-1];
  140.                                 Start_Display(value);
  141.                                 Dio_WriteChannel(DIO_PA_14,STD_HIGH);
  142.                                 value=inputSeq[x];
  143.                                 Start_Display(value);
  144.                         }
  145.                         if(z=3){
  146.                                 Dio_WriteChannel(DIO_PA_11,STD_HIGH);
  147.                                 value=inputSeq[x-3];
  148.                                 Start_Display(value);
  149.                                 Dio_WriteChannel(DIO_PA_12,STD_HIGH);
  150.                                 value=inputSeq[x-2];
  151.                                 Start_Display(value);
  152.                                 Dio_WriteChannel(DIO_PA_13,STD_HIGH);
  153.                                 value=inputSeq[x-1];
  154.                                 Start_Display(value);
  155.                                 Dio_WriteChannel(DIO_PA_14,STD_HIGH);
  156.                                 value=inputSeq[x];
  157.                                 Start_Display(value);
  158.                         }
  159.                         if(z=2){
  160.                                 Dio_WriteChannel(DIO_PA_10,STD_HIGH);
  161.                                 value=inputSeq[x-4];
  162.                                 Start_Display(value);
  163.                                 Dio_WriteChannel(DIO_PA_11,STD_HIGH);
  164.                                 value=inputSeq[x-3];
  165.                                 Start_Display(value);
  166.                                 Dio_WriteChannel(DIO_PA_12,STD_HIGH);
  167.                                 value=inputSeq[x-2];
  168.                                 Start_Display(value);
  169.                                 Dio_WriteChannel(DIO_PA_13,STD_HIGH);
  170.                                 value=inputSeq[x-1];
  171.                                 Start_Display(value);
  172.                                 Dio_WriteChannel(DIO_PA_14,STD_HIGH);
  173.                                 value=inputSeq[x];
  174.                                 Start_Display(value);
  175.                         }
  176.                         if(z=1){
  177.                                 Dio_WriteChannel(DIO_PA_9,STD_HIGH);
  178.                                 value=inputSeq[x-5];
  179.                                 Start_Display(value);
  180.                                 Dio_WriteChannel(DIO_PA_10,STD_HIGH);
  181.                                 value=inputSeq[x-4];
  182.                                 Start_Display(value);
  183.                                 Dio_WriteChannel(DIO_PA_11,STD_HIGH);
  184.                                 value=inputSeq[x-3];
  185.                                 Start_Display(value);
  186.                                 Dio_WriteChannel(DIO_PA_12,STD_HIGH);
  187.                                 value=inputSeq[x-2];
  188.                                 Start_Display(value);
  189.                                 Dio_WriteChannel(DIO_PA_13,STD_HIGH);
  190.                                 value=inputSeq[x-1];
  191.                                 Start_Display(value);
  192.                                 Dio_WriteChannel(DIO_PA_14,STD_HIGH);
  193.                                 value=inputSeq[x];
  194.                                 Start_Display(value);
  195.                                 z++;
  196.                         }
  197.                 z--;
  198.                 void OS_Wait(uint32_t delayMs);
  199.         }
  200.         }
  201.                 //OS_GetActualTime();
  202.     printf("This is a native C program.\n");
  203.         system("pause");
  204.     return 0;
  205. }





Il Test Ŕ per un'azienda di Praga, ho superato la prova di inglese e di tedesco, poi ho superato il VHDL, e adesso devo superare questo test

PM
Avatar
nessuno (Normal User)
Guru^2


Messaggi: 5475
Iscritto: 03/01/2010

Segnala al moderatore
Postato alle 22:27
Martedý, 01/12/2015
Ma il C lo conosci? SarÓ dura se scrivi

if(z=6){

e simili


Ricorda che nessuno Ŕ obbligato a risponderti e che nessuno Ŕ perfetto ...
PM
Avatar
Ultimo (Member)
Expert


Messaggi: 513
Iscritto: 22/05/2010

Segnala al moderatore
Postato alle 22:40
Martedý, 01/12/2015
Testo quotato

Postato originariamente da nessuno:

Ma il C lo conosci? SarÓ dura se scrivi

if(z=6){

e simili



:k: eheheheh gli hai dato la soluzione


Ultimo (Hai voluto la bicicletta ? ....)

Studiare LINQ, WPF, ASP.NET MVC, Entity Framwork, C#, Blend, XAML, Javascript, HTML5, CSS .....(tanta roba)

https://www.dropbox.com/s/c2aots5x4urgbhf/setup_game_sudoku ...
PM
Avatar
lumo (Member)
Expert


Messaggi: 416
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 3:39
Mercoledý, 02/12/2015
Mannaggia non conosco VHDL. Allora ti aiuto, ma metti una parola buona su di me.

Codice sorgente - presumibilmente C/C++

  1. static uint32_t delayMs= 1000; // che significa static uint32_t??????


uint32_t bedeutet, dass delayMs eine 32-bit unvorzeichene Zahl ist. Auf eine 32-bit Architektur ist es dasselbe wie unsigned int.
Static hei▀t, dass die Variable wńhrend der AusfŘhrung in einer unverńndbaren Addresse steht. In diesem Zusammenhang ist static ganz unn÷tig.
Codice sorgente - presumibilmente C/C++

  1. char inputSeq[] = ("3.14159265358979323846264338327950288...


Auch hier sind die Klammern unn÷tig.
Codice sorgente - presumibilmente C/C++

  1. void OS_Wait(uint32_t delayMs);


Diese Zeile ist nicht korrekt. Wenn du warten willst,musst du OS_Wait (delayMs); schreiben.

Das ▄brige ergńnze ich spńter.
Welche API benutzt du dabei?

PM
Pagine: [ 1 2 3 ] Precedente | Prossimo