Oscilloscope numérique

  1. /*--------------------------------------------------------------------------------
  2. 'Nom du projet : Oscilloscope
  3. 'Outil : Visual C++ 6
  4. 'Nom du fichier: MemoryFile.cpp
  5. 'Realisation:Mathieu Texier et Emmanuel Traineau
  6. 'Date: Juin 2003
  7. 'Responsable: Eric Meleiro
  8. '--------------------------------------------------------------------------------
  9.  
  10.  
  11.  
  12. Explications : Ce fichier contient les fonctions membres permettant la manipulation des données mémoires
  13.  
  14. */
  15.  
  16. #include "stdafx.h"
  17. #include "Port.h"
  18. #include "MemoryFile.h"
  19.  
  20. #ifdef _DEBUG
  21. #define new DEBUG_NEW
  22. #undef THIS_FILE
  23. static char THIS_FILE[] = __FILE__;
  24. #endif
  25. extern BYTE* pbufferEntree;
  26. extern bool Flg_action ;
  27. // Constructeur de la classe: initialise le bloc mémoire
  28. CMemoryFile::CMemoryFile()
  29. {
  30.         hglobal = NULL;
  31. }
  32.  
  33. // Destructeur : fige le bloc mémoire sur la rame
  34. CMemoryFile::~CMemoryFile()
  35. {
  36.         if (hglobal)
  37.         {
  38.                 GlobalUnlock (hglobal);
  39.                 GlobalFree (hglobal);
  40.         }
  41. }
  42.  
  43. // lit les parties d'un fichier dans la mémoire
  44. void *CMemoryFile::Read (UINT start, UINT end)
  45. {
  46.         // Curseur
  47.         SetCursor (LoadCursor (NULL, IDC_WAIT));
  48.  
  49.         // détermine sa longueur
  50.         size = end-start;
  51.  
  52.  
  53.         // Si le bloc mémoire a déjà été utilisé, - > libérer
  54.         if (hglobal)
  55.         {
  56.                 GlobalUnlock (hglobal);
  57.                 GlobalFree (hglobal);
  58.         }
  59.  
  60.  
  61.         // allocation du bloc mémoire ( +512 pour les entêtes wave )
  62.         hglobal = GlobalAlloc (GHND, size + 512);
  63.         memptr = GlobalLock (hglobal);
  64.         if (!memptr)
  65.                 ::MessageBox (NULL, "GlobalAlloc failed....",
  66.                 "CMemoryFile::Read", MB_ICONSTOP | MB_OK);
  67.        
  68.         // si on est en mode acquisition
  69.  
  70.         if (Flg_action == 1)
  71.         {
  72.         // Ouverture du buffer
  73.                 CMemFile m_memfile;
  74.                 m_memfile.Attach( pbufferEntree, BUFFER_LENGHT, 0 );
  75.                 m_memfile.Seek (start, CFile::begin);
  76.                 m_memfile.Read(memptr, size );
  77.  
  78.         }
  79.         else
  80.         {
  81.                 CFile::Seek (start, CFile::begin);     
  82.                 CFile::Read     (memptr, size);
  83.         }
  84.  
  85.  
  86.         // positionne le cuseur
  87.         SetCursor (LoadCursor (NULL, IDC_ARROW));
  88.  
  89.         // retourne le pointeur sur la ram
  90.  
  91.         return memptr;
  92. }
  93.  
  94. // Dreht den Speicher um
  95. void CMemoryFile::Reverse (void)
  96. {
  97.         // Nix zum Umdrehen, dann 'raus
  98.         if (!hglobal)
  99.                 return;
  100.        
  101.         // Cursor auf EierUhr
  102.         SetCursor (LoadCursor (NULL, IDC_WAIT));
  103.        
  104.         // Pointer und Schleifenzaehler anlegen
  105.         BYTE *tmp = new BYTE[size];
  106.         BYTE *mem = (BYTE*)memptr;
  107.         UINT s;
  108.  
  109.         // Speicherinhalt umdrehen...
  110.         for (s=size; s>0; s--)
  111.                 tmp[size-s] = mem[s];
  112.  
  113.         // und zurueckschreiben
  114.         for (s=0; s<size; s++)
  115.                 mem[s] = tmp[s];
  116.  
  117.         // Temporaeres Array freigeben
  118.         delete[] tmp;
  119.  
  120.         // Cursor wieder auf Pfeil
  121.         SetCursor (LoadCursor (NULL, IDC_ARROW));
  122. }
  123.  
  124. // Addiert ein BYTE zu jedem Byte im Speicher
  125. void CMemoryFile::AddByte (BYTE byte)
  126. {
  127.         // Nix zum Umdrehen, dann 'raus
  128.         if (!hglobal)
  129.                 return;
  130.  
  131.         // Cursor auf EierUhr
  132.         SetCursor (LoadCursor (NULL, IDC_WAIT));
  133.  
  134.         // BYTE aufaddieren
  135.         BYTE *mem = (BYTE*)memptr;
  136.         UINT s;
  137.         for (s=0; s<size; s++)
  138.                 mem[s] += byte;
  139.  
  140.         // Cursor wieder auf Pfeil
  141.         SetCursor (LoadCursor (NULL, IDC_ARROW));
  142. }
  143.  
  144. // XOR'd alle Bytes im Speicher
  145. void CMemoryFile::XorByte (BYTE byte)
  146. {
  147.         // Nix zum Umdrehen, dann 'raus
  148.         if (!hglobal)
  149.                 return;
  150.  
  151.         // Cursor auf EierUhr
  152.         SetCursor (LoadCursor (NULL, IDC_WAIT));
  153.  
  154.         // BYTE xorren
  155.         BYTE *mem = (BYTE*)memptr;
  156.         UINT s;
  157.         for (s=0; s<size; s++)
  158.                 mem[s] ^= byte;
  159.  
  160.         // Cursor wieder auf Pfeil
  161.         SetCursor (LoadCursor (NULL, IDC_ARROW));
  162. }
  163.  

contact - faire un lien