Elektroda.pl
Elektroda.pl
X
Proszę, dodaj wyjątek www.elektroda.pl do Adblock.
Dzięki temu, że oglądasz reklamy, wspierasz portal i użytkowników.

builder C++ operacje na tablicach

jerraz 05 Maj 2010 20:04 924 4
  • #1 05 Maj 2010 20:04
    jerraz
    Poziom 10  

    Witam, mam prośbę. Mam 5 czujników. Każdy czujnik wysyła 3 bajty.

    Pierwszy mówi mi o tym który to jest czujnik (0;1;2;3;4). Drugi to starszy

    bajt paczki danych. Trzeci to młodszy bajt. Teraz tak bufor zapełnia się

    danymi i teraz muszę wyłuskać konkretne mnie bajty.
    robię modulo 15 tak,by mieć pełny pakiet dla wszystkich 5 czujników (5

    czujników po 3 bajty).
    Kolejno za pomocą operacji na reszcie z dzielenia 15 wybieram
    - kolejność - czyli informacje który to czujnik;
    - starszy bajt;
    - młodszy bajt;
    i zapisuje je w plikach.
    teraz sklejenie starszego i młodszego wygląda tak:

    wynik[i]=starszy[i]*256+młodszy[i];

    niestety składanie tych bajtów nie wychodzi mi poprawnie.

    Mógłby ktoś rzucić co robię źle?

    z góry dzięki.

    Proszę umieszczać kod w znacznikach code lub załączniku, a nie linkować do zewnętrznych stron.
    Sugeruję nie wklejać całego kodu, tylko odpowiedni fragment lub funkcję.
    Dr.Vee



    Code:
    void __fastcall TForm1::Button2Click(TObject *Sender)
    
    {//x

    if (hNumPort > 0)               // jezeli port jest otwarty
    {//a

            Read_Comm(hNumPort, &Buffer_I[0], &Number_Bytes_Read,
            sizeof(Buffer_I));

            if (Number_Bytes_Read > 0)      // jeżeli odebrano jakieś bajty
            {//b
             int k=0;
                  int z=0;
                  //int c=0;
                  for( int i=0; i < Number_Bytes_Read; i++ )
                  {//l

                          z = i%15;
                          //Memo14->Lines->Add(z);                                              // modulo 15 pozwala na wyluskanie pelnej paczki pomiarow dla 5 czujnikow
                          if((i!= 0) && (z==0))
                          {//k
                                  Memo3->Lines->Add("123");
                          };//k





                          if( (z==0 || z==3 || z==6 || z==9 || z==12)) // kolejnosc
                          {
                                  kolejnosc[k] = Buffer_I[i];
                                  Memo4->Lines->Add(kolejnosc[k]);

                          };

                          if ((z==1||z==4||z==7||z==10||z==13))       // starszy bit
                          {
                                  starszy[k] = Buffer_I[i];
                                  Memo5->Lines->Add(starszy[k]);

                                            //starszyp[k] = starszy[k];
                                            //if (starszy[k] == 192)  {
                                            //starszyp[k] = 0;        };
                                            //Memo12->Lines->Add(starszyp[k]);

                          };

                          if ((z==2||z==5||z==8||z==11||z==14))     // mlodszy bit
                          {
                                  mlodszy[k] = Buffer_I[i];
                                  Memo6->Lines->Add(mlodszy[k]);

                          };

                                  wynikp[k] = (starszy[k])*256 + mlodszy[k];
                                  Memo13->Lines->Add(wynikp[i]);

    //=========================================================================

                                    // k = z%3;
                                    // Memo15->Lines->Add(k);
                                    // Memo15->Lines->SaveToFile("k.dat");
                                    //if (k==1||k==2){
                                    //if ((z==1||z==2||z==4||z==5||z==7||z==8||z==10||z==11||z==13||z==14)){

                                    //if (z!=0||z!=3||z!=6||z!=9||z!=12){
                                    //wynikp[z] = starszyp[z]*256+mlodszy[z];
                                    //Memo13->Lines->Add(wynikp[z]);                                     //};
                                    //wynik[i] = (wynikp[i])/2;
                                    //         }
                                    Memo13->Lines->SaveToFile("wynikp.dat");
                                   
                                    if (kolejnosc[z]==0||kolejnosc[z]==1||kolejnosc[z]==2||kolejnosc[z]==3||kolejnosc[z]==4)
                                    {
                                    pomiary.czujnik_0[i]=wynik[i];
                                    //Memo7->Lines->Add(pomiary.czujnik_0[i]);
                                    //Memo7->Lines->SaveToFile("1.dat");
                                    }
       

    0 4
  • #2 05 Maj 2010 23:18
    redie
    Poziom 15  

    Jeśli dobrze widzę, to w tej pętli nie inkrementujesz wogóle zmiennej 'k', a do tego przy obliczaniu wyniku końcowego masz tak:

    Code:
    wynikp[k] = (starszy[k])*256 + mlodszy[k];
    
    Memo13->Lines->Add(wynikp[i]);

    czyli wynik zawsze zostaje umieszczony w indeksie 0, a do Memo13 dodajesz to co masz pod indexem 'i'. Chyba nie o to ci chodziło.

    0
  • #3 06 Maj 2010 00:40
    jerraz
    Poziom 10  

    ok moj blad byl w odpowiedniej iteracji

    powinno wygladac mniej wiecej tak:

    Code:
    //---------------------------------------------------------------------------
    

    #include <vcl.h>
    #pragma hdrstop

    #include "Unit1.h"
    //---------------------------------------------------------------------------
    #pragma package(smart_init)
    #pragma resource "*.dfm"
    TForm1 *Form1;
    int kolejnosc[300];
    int starszy[300];
    int mlodszy[300];
    int bufor[300];
    float wynik[300];

    //---------------------------------------------------------------------------
    __fastcall TForm1::TForm1(TComponent* Owner)
            : TForm(Owner)
    {
    }
    //---------------------------------------------------------------------------

    void __fastcall TForm1::Button1Click(TObject *Sender)
    {
    for ( int b = 0; b <= 300; b++ )//czyszczenie tablic kolejnosc starszymlodszy wynik wynikp pomiary
    {
    kolejnosc[b] = 0;
    starszy[b] = 0;
    mlodszy[b] = 0;
    wynik[b] = 0.0;
    }

    Memo1->Clear(); // czyszczenie memo1...7
    //Memo2->Clear();
    int k=0;
    for (int i=1; i<200; i++)
            {
            bufor[i]=i;
            Memo1->Lines->Add(bufor[i]);
            int o = i%3;
            if ((o==0 || o==1||o==2))
                    {
            Memo2->Lines->Add(o);
                    }

            if (o==0)
                    {
            kolejnosc[k] = bufor[i];
            Memo3->Lines->Add(kolejnosc[k]);
                    }

            if (o==1)
                    {
            starszy[k] = bufor[i];
            Memo4->Lines->Add(starszy[k]);
                    }

            if (o==2)
                    {
            mlodszy[k] = bufor[i];
            Memo5->Lines->Add(mlodszy[k]);
            wynik[k]=starszy[k]+mlodszy[k];
            Memo6->Lines->Add(wynik[k]);
                k++;
                    }

            }

            Memo1->Lines->SaveToFile("bufor.dat");
            //Memo2->Lines->SaveToFile("o.dat");
            Memo3->Lines->SaveToFile("kolejnosc.dat");
            Memo4->Lines->SaveToFile("starszy.dat");
            Memo5->Lines->SaveToFile("mlodszy.dat");
            Memo6->Lines->SaveToFile("wynik.dat");
    }
    //---------------------------------------------------------------------------



    teraz chcialbym odnosic sie do wynik[k], na takiej zasadzie, ze mam utworzona strukture pomiary

    Code:
    struct pomiary_c // struktura pomiary do przechowywania wynikow z kazdego czujnika
    
    {
          float czujnik_0[500]; // pomiary czujnika 1 [500]
          float czujnik_1[500]; // pomiary czujnika 2 [500]
          float czujnik_2[500]; // pomiary czujnika 3 [500]
          float czujnik_3[500]; // pomiary czujnika 4 [500]
          float czujnik_4[500]; // pomiary czujnika 5 [500]
    };
    pomiary_c pomiary;


    i chcialbym odpowiednie wyniki tam wrzucac

    Code:

                                    if (kolejnosc[k]==1)
                                    {
                                    pomiary.czujnik_1[i]=wynik[k];
                                    Memo8->Lines->Add(pomiary.czujnik_1[i]);
                                    Memo8->Lines->SaveToFile("2.dat");
                                    }

    ale nie chce dzialac, dlaczego?

    0
  • #4 06 Maj 2010 00:43
    utak3r
    Poziom 25  

    A co to znaczy "nie chce działać"? Co się dzieje?

    BTW, masz: wynik[k]=starszy[k]+mlodszy[k]; a przesunięcie w lewo starszego bajtu?

    0
  • #5 06 Maj 2010 00:58
    jerraz
    Poziom 10  

    do pomiary.czujnik_1[i] wypisuje same 0;
    Co do przesuniecia starszego bajtu to wiem jak to zrobic, poprostu nie chce tego umieszczac,zeby nie zaciemniac juz bardziej.

    0