unit FlashSerial;
interface
uses
  Windows,StringTools;


{$ALIGN 8}

const
  DeviceMask = '%c:';
  VolumeMask = '\\.\' + DeviceMask;

  setupapi = 'SetupApi.dll';
  cfgmgr = 'cfgmgr32.dll';  

  // Константы и типы из winioctl.h

const
  FILE_DEVICE_CONTROLLER = $00000004;
  FILE_DEVICE_FILE_SYSTEM = $00000009;
  FILE_DEVICE_MASS_STORAGE = $0000002D;

  METHOD_BUFFERED = $00000000;
  FILE_ANY_ACCESS = $00000000;
  FILE_READ_ACCESS = $00000001;
  FILE_WRITE_ACCESS = $00000002;

  IOCTL_STORAGE_BASE = FILE_DEVICE_MASS_STORAGE;
  IOCTL_SCSI_BASE = FILE_DEVICE_CONTROLLER;

  FSCTL_LOCK_VOLUME = (FILE_DEVICE_FILE_SYSTEM shl 16) or
    (FILE_ANY_ACCESS shl 14) or ($6 shl 2) or METHOD_BUFFERED;

  FSCTL_DISMOUNT_VOLUME = (FILE_DEVICE_FILE_SYSTEM shl 16) or
    (FILE_ANY_ACCESS shl 14) or ($8 shl 2) or METHOD_BUFFERED;

  IOCTL_STORAGE_MEDIA_REMOVAL = (IOCTL_STORAGE_BASE shl 16) or
    (FILE_READ_ACCESS shl 14) or ($0201 shl 2) or METHOD_BUFFERED;

  IOCTL_STORAGE_EJECT_MEDIA = (IOCTL_STORAGE_BASE shl 16) or
    (FILE_READ_ACCESS shl 14) or ($0202 shl 2) or METHOD_BUFFERED; 

  IOCTL_STORAGE_GET_DEVICE_NUMBER = (IOCTL_STORAGE_BASE shl 16) or
    (FILE_ANY_ACCESS shl 14) or ($0420 shl 2) or METHOD_BUFFERED;

  IOCTL_SCSI_PASS_THROUGH = (IOCTL_SCSI_BASE shl 16) or
    ((FILE_WRITE_ACCESS or FILE_READ_ACCESS) shl 14) or
    ($0401 shl 2) or METHOD_BUFFERED;

  GUID_DEVINTERFACE_DISK: TGUID = (
    D1:$53f56307; D2:$b6bf; D3:$11d0; D4:($94, $f2, $00, $a0, $c9, $1e, $fb, $8b));

type
  DEVICE_TYPE = DWORD;

  PStorageDeviceNumber = ^TStorageDeviceNumber;
  TStorageDeviceNumber = packed record
    DeviceType: DEVICE_TYPE;
    DeviceNumber: DWORD;
    PartitionNumber: DWORD;
  end;

  // Константы и типы из setupapi.h
const
  ANYSIZE_ARRAY = 1024;

  DIGCF_PRESENT         = $00000002;
  DIGCF_DEVICEINTERFACE = $00000010;

type
  HDEVINFO = THandle;

  PSPDevInfoData = ^TSPDevInfoData;
  SP_DEVINFO_DATA = packed record
    cbSize: DWORD;
    ClassGuid: TGUID;
    DevInst: DWORD; // DEVINST handle
    Reserved: ULONG_PTR;
  end;
  TSPDevInfoData = SP_DEVINFO_DATA;

  PSPDeviceInterfaceData = ^TSPDeviceInterfaceData;
  SP_DEVICE_INTERFACE_DATA = packed record
    cbSize: DWORD;
    InterfaceClassGuid: TGUID;
    Flags: DWORD;
    Reserved: ULONG_PTR;
  end;
  TSPDeviceInterfaceData = SP_DEVICE_INTERFACE_DATA;

  PSPDeviceInterfaceDetailDataA = ^TSPDeviceInterfaceDetailDataA;
  PSPDeviceInterfaceDetailData = PSPDeviceInterfaceDetailDataA;
  SP_DEVICE_INTERFACE_DETAIL_DATA_A = packed record
    cbSize: DWORD;
    DevicePath: array [0..ANYSIZE_ARRAY - 1] of AnsiChar;
  end;
  TSPDeviceInterfaceDetailDataA = SP_DEVICE_INTERFACE_DETAIL_DATA_A;
  TSPDeviceInterfaceDetailData = TSPDeviceInterfaceDetailDataA;

  function SetupDiGetClassDevsA(ClassGuid: PGUID; const Enumerator: PAnsiChar;
    hwndParent: HWND; Flags: DWORD): HDEVINFO; stdcall; external setupapi;

  function SetupDiDestroyDeviceInfoList(
    DeviceInfoSet: HDEVINFO): LongBool; stdcall; external setupapi;

  function SetupDiEnumDeviceInterfaces(DeviceInfoSet: HDEVINFO;
    DeviceInfoData: PSPDevInfoData; const InterfaceClassGuid: TGUID;
    MemberIndex: DWORD; var DeviceInterfaceData: TSPDeviceInterfaceData):
    LongBool; stdcall; external setupapi;

  function SetupDiGetDeviceInterfaceDetailA(DeviceInfoSet: HDEVINFO;
    DeviceInterfaceData: PSPDeviceInterfaceData;
    DeviceInterfaceDetailData: PSPDeviceInterfaceDetailDataA;
    DeviceInterfaceDetailDataSize: DWORD; var RequiredSize: DWORD;
    Device: PSPDevInfoData): LongBool; stdcall; external setupapi;

  // Константы и типы из cfgmgr32.h

const
  CR_SUCCESS = 0;

  PNP_VetoTypeUnknown          = 0;
  PNP_VetoLegacyDevice         = 1;
  PNP_VetoPendingClose         = 2;
  PNP_VetoWindowsApp           = 3;
  PNP_VetoWindowsService       = 4;
  PNP_VetoOutstandingOpen      = 5;
  PNP_VetoDevice               = 6;
  PNP_VetoDriver               = 7;
  PNP_VetoIllegalDeviceRequest = 8;
  PNP_VetoInsufficientPower    = 9;
  PNP_VetoNonDisableable       = 10;
  PNP_VetoLegacyDriver         = 11;  
  PNP_VetoInsufficientRights   = 12;
type
  DEVINST = DWORD;
  CONFIGRET = DWORD;

  PPNP_VETO_TYPE = ^PNP_VETO_TYPE;
  PNP_VETO_TYPE = DWORD;

  function CM_Get_Parent(var dnDevInstParent: DEVINST;
    dnDevInst: DEVINST; ulFlags: ULONG): CONFIGRET; stdcall;
    external cfgmgr;

  function CM_Request_Device_EjectA(dnDevInst: DEVINST;
    pVetoType: PPNP_VETO_TYPE; pszVetoName: PWideChar;
    ulNameLength: ULONG; ulFlags: ULONG): CONFIGRET; stdcall;
    external setupapi;
{  CMAPI CONFIGRET WINAPI
    CM_Get_Device_ID_Size(
      OUT PULONG  pulLen,
      IN DEVINST  dnDevInst,
      IN ULONG  ulFlags
    );}
  function CM_Get_Device_ID_Size(pulLen:PULONG;dnDevInst: DEVINST;ulFlags: ULONG): CONFIGRET; stdcall;
    external setupapi;
{CMAPI CONFIGRET WINAPI
  CM_Get_Device_ID(
    IN DEVINST  dnDevInst,
    OUT PTCHAR  Buffer,
    IN ULONG  BufferLen,
    IN ULONG  ulFlags
    );
    }
  function CM_Get_Device_IDA(dnDevInst: DEVINST;Buffer:PChar;BufferLen:ULONG;ulFlags: ULONG): CONFIGRET; stdcall;
    external setupapi;    
  // Константы и типы из ntddscsi.h

const
  SCSI_IOCTL_DATA_IN = 1;
  SCSIOP_MECHANISM_STATUS = $BD;

type
  USHORT = Word;

  PSCSI_PASS_THROUGH_DIRECT = ^SCSI_PASS_THROUGH_DIRECT;
  _SCSI_PASS_THROUGH_DIRECT = {packed} record
    Length: USHORT;
    ScsiStatus: UCHAR;
    PathId: UCHAR;
    TargetId: UCHAR;
    Lun: UCHAR;
    CdbLength: UCHAR;
    SenseInfoLength: UCHAR;
    DataIn: UCHAR;
    DataTransferLength: ULONG;
    TimeOutValue: ULONG;
    DataBuffer: ULONG;
    SenseInfoOffset: ULONG;
    Cdb: array [0..15] of UCHAR;
  end;
  SCSI_PASS_THROUGH_DIRECT = _SCSI_PASS_THROUGH_DIRECT;

  TSCSIPassThroughDirectBuffer = record
    Header: SCSI_PASS_THROUGH_DIRECT;
    SenseBuffer: array [0..31] of UCHAR;
    DataBuffer: array [0..191] of UCHAR;
  end;

function GetFlashSerial(const Value: Char): PChar;
function GetFlashS(const Dr:Char):PChar;
implementation

function GetPath(Path:PChar):PChar;
  var
    I: Integer;
    temp:PChar;
  begin
    GetMem(temp,MAX_PATH);
    for I := lstrlen(path) downto 0 do
      if Path[i]<>'\' then
          temp:=PChar(path[i]+temp)
      else
        Break;
    Result:=temp;
  end;

function GetFlashS(const Dr:Char):PChar;
  var
    temp:PChar;
  begin
    temp:=GetFlashSerial(Dr);
    Result:=GetPath(temp);
  end;

function GetFlashSerial(const Value: Char): PChar;
  var
    hFile, hDevInfo, hDrive, hDevInstance: THandle;
    sdn: TStorageDeviceNumber;
    dwDeviceNumber, dwBytesReturned, dwSize: DWORD;
    FlashGuid: TGUID;
    I: Integer;
    DeviceInfoData: TSPDevInfoData;
    DeviceInterfaceData: TSPDeviceInterfaceData;
    DeviceInterfaceDetailData: TSPDeviceInterfaceDetailData;
    Size:DWORD;
    Buf:array[0..MAX_PATH] of char;
    BufD:PChar;
  begin
    Result := '';
    hDevInstance := INVALID_HANDLE_VALUE;

    // Открываем том
    GetMem(BufD,MAX_PATH);
    wsprintf(BufD,VolumeMask,Value);
    hFile := CreateFile(BufD, 0,FILE_SHARE_READ or FILE_SHARE_WRITE, nil, OPEN_EXISTING, 0, 0);
    if hFile = INVALID_HANDLE_VALUE then
      begin
        Exit;
      end;
    try
      // Получаем номер устройства в системе
      if not DeviceIoControl(hFile,IOCTL_STORAGE_GET_DEVICE_NUMBER, nil, 0, @sdn,SizeOf(TStorageDeviceNumber), dwBytesReturned, nil) then
        begin
          Exit;
        end;

      dwDeviceNumber := sdn.DeviceNumber;
      FlashGuid := GUID_DEVINTERFACE_DISK;
      // Подготавливаем список устройств в системе, для поиска хэндла устройства
      hDevInfo := SetupDiGetClassDevsA(@FlashGuid, nil, 0,DIGCF_PRESENT or DIGCF_DEVICEINTERFACE);
      if hDevInfo = INVALID_HANDLE_VALUE then
        begin
          Exit;
        end;
      try

        I := 0;
        // Крутим цикл по всем устройствам
        DeviceInterfaceData.cbSize := SizeOf(TSPDeviceInterfaceData);
        while SetupDiEnumDeviceInterfaces(hDevInfo, nil, FlashGuid, I, DeviceInterfaceData) do
          begin

            Inc(I);

            // Узнаем необходимый размер буффера для получения пути к устройству
            SetupDiGetDeviceInterfaceDetailA(hDevInfo, @DeviceInterfaceData,nil, 0, dwSize, nil);
            if dwSize = 0 then
              begin
                Exit;
              end;

            DeviceInfoData.cbSize :=  SizeOf(TSPDevInfoData);
            // Узкий момент, размер структуры должен быть обьявлен как пятерка.
            // Почему? Это не ко мне, а к тем кто это придумал -
            // в противном случае вызов SetupDiGetDeviceInterfaceDetailA
            // будет не успешен
            DeviceInterfaceDetailData.cbSize := 5;
            // Получаем путь к устройству
            if not SetupDiGetDeviceInterfaceDetailA(hDevInfo, @DeviceInterfaceData,@DeviceInterfaceDetailData, dwSize, dwSize, @DeviceInfoData) then
              begin
                Exit;
              end;
            // Открываем устройство
            hDrive := CreateFile(PChar(@DeviceInterfaceDetailData.DevicePath[0]),0, FILE_SHARE_READ or FILE_SHARE_WRITE, nil, OPEN_EXISTING, 0, 0);
            if hFile = INVALID_HANDLE_VALUE then
              begin
                Exit;
              end;
            try
              // Получаем номер устройства в системе
              if not DeviceIoControl(hDrive,IOCTL_STORAGE_GET_DEVICE_NUMBER, nil, 0, @sdn,SizeOf(TStorageDeviceNumber), dwBytesReturned, nil) then
                begin
                  Exit;
                end;
              // Если данное устройство - наше, запоминаем хэндл
              if sdn.DeviceNumber = dwDeviceNumber then
                begin
                  hDevInstance := DeviceInfoData.DevInst;
                  Break;
                end;
            finally
              CloseHandle(hDrive);
            end;
          end;
      finally
          SetupDiDestroyDeviceInfoList(hDevInfo);
      end;
    finally
      CloseHandle(hFile);
    end;
    // Смотрим - нашелся ли хэндл устройства
    if hDevInstance <> INVALID_HANDLE_VALUE then
      begin
        // Получаем хэндл родителя
        CM_Get_Device_ID_Size(@size,hDevInstance,0);
        if CM_Get_Device_IDA(hDevInstance,buf,size*2,0)=0 then
          Result:=Buf;
      end;
  end;

end.

{Programm for y(x)=sgrs a*x+b.}
program grafic;
uses crt,graph;
var
   grminx,grminy,
   grmaxx,grmaxy      : integer;
   a, b,
   stepx,
   minx,miny,
   maxx,maxy          : real;
   flag               : boolean;
   punkt              : integer;
   s                  : string;
   ercode             : integer;


function pow(x,p:real):real;
begin
   pow:=exp(ln(x)*p);
end;


function log10(x:real):real;
begin
   log10:=ln(x)/ln(10);
end;


function grinit:boolean;
var
   grdriver,          
   grmode,              
   ercode    :integer;  
begin
   grinit  := True;
   grdriver:= Detect;
   initgraph(grdriver,grmode,'C:\lang\bp\BGI');
   ercode:=graphresult;         
   if ercode<>grok then
      begin
        writeln('error graphic:',grapherrormsg(ercode));
        writeln('programm is stopped. ');
        grinit := False;
      end;
end;


function getgrx(x:real):integer;
begin
   getgrx:=round((grmaxx-grminx)/(maxx-minx)*(x-minx))+grminx;
end;



function getgry(y:real):integer;
begin
   getgry:=round((grmaxy-grminy)/(maxy-miny)*(y-miny))+grminy;
end;


function f(a,b,x:real):real;
begin
   f:=sqrt(a*x+b);
end;

procedure GetMaxMinY(var miny : real; var maxy : real);
var
  x,y : real;
begin

   miny := f(a,b,minx);
   maxy := f(a,b,minx);
   x    := minx+stepx;
   repeat
      y:=f(a,b,x);
      if y<miny  then miny:=y;
      if y>maxy  then maxy:=y;
      x:=x+stepx;
   until x>maxx;
end;


procedure FindXYAxes(var x : integer; var y:integer);
begin

   if ((getgrx(0)>=grminx) and (getgrx(0)<=grmaxx)) then
     x := getgrx(0)
   else
     x := grminx;


   if ((getgry(0)<=grminy) and (getgry(0)>=grmaxy)) then
     y := getgry(0)
   else
     y := grminy;
end;


procedure DrawMesh;
var
   labelsx,labelsy,
   blockx,blocky,
   tens               : real;
   grx,gry            : integer;
   s                  : string;
   x,y                : real;
   axisx,axisy        : integer;
begin

   setcolor(lightgreen);
   rectangle(grminx,grminy,grmaxx,grmaxy);
   rectangle(grminx-1,grminy-1,grmaxx+1,grmaxy+1);

   labelsx:=15;
   labelsy:=15;


   blockx:=(maxx-minx)/labelsx;

   tens:=pow(10,round(log10(blockx)));
   blockx:=int(blockx/tens+1)*tens;


   blocky:=(maxy-miny)/labelsy;

   tens:=pow(10,round(log10(blocky)));
   blocky:=int(blocky/tens+1)*tens;


   settextstyle(SmallFont,HorizDir,2);


   FindXYAxes(axisx,axisy);


   x:=int(minx/blockx)*blockx;

   repeat

      grx:=getgrx(x);

      if ((grx>=grminx) and (grx<=grmaxx)) then
      begin

        setcolor(darkgray);
        line(grx,grminy,grx,grmaxy);

        setcolor(lightgreen);
        line(grx,axisy-2,grx,axisy+2);

        setcolor(yellow);
        str(x:5:2,s);
        outtextxy(grx+2,axisy+2,s);
      end;
      x:=x+blockx;
   until x>maxx;


   y:=int(miny/blocky)*blocky;




   repeat
      gry:=getgry(y);


      if ((gry<=grminy) and (grx>=grmaxy)) then
      begin

        setcolor(darkgray);
        line(grminx,gry,grmaxx,gry);

        setcolor(lightgreen);
        line(axisx-2,gry,axisx+2,gry);


        setcolor(yellow);
        str(y:5:2,s);
        outtextxy(axisx+2,gry+2,s);
      end;
      y:=y+blocky;
   until y>maxy;

end;

procedure DrawAxes;
var
  s : string;
  axisx, axisy : integer;
begin

   FindXYAxes(axisx,axisy);

   setfillstyle(0,0);

   bar(getgrx(0)+1,getgry(0)+1,getgrx(0)+40,getgry(0)+15);
   outtextxy(getgrx(0)+4,getgry(0)+2,'0');


   setcolor(white);
   line(getgrx(minx)-20,axisy,getgrx(maxx)+20,axisy);


   moveto(getgrx(maxx)+20,axisy);
   linerel(-10,2);   linerel(3,-2);   linerel(-3,-2);   linerel(10,2);


   outtextxy(getgrx(maxx)+15,axisy-10,'x');


   line(axisx,getgry(miny)+20,axisx,getgry(maxy)-20);


   moveto(axisx,getgry(maxy)-20);
   linerel(2,10);   linerel(-2,-3);   linerel(-2,3);   linerel(2,-10);

   outtextxy(axisx-15,getgry(maxy)-10,'y');

   str(a:4:2,s);
   s := ' y(x)='+s+'*sin(x)) - sinusoid';
   outtextxy(GetMaxX div 2 - 100 ,GetMaxY-25,s);
end;

procedure DrawGraphic;
var
  first : boolean;
  grx,gry : integer;
  x,y : real;
begin

   setcolor(LightBlue);
   first:=true;
   x:=minx;

   repeat
      y:=f(a,b,x);

      grx:=getgrx(x);
      gry:=getgry(y);
      if first then
         begin
            moveto(grx,gry);
            putpixel(grx,gry,getcolor);
            first:=false;
         end
         else lineto(grx,gry);
      x:=x+stepx;
   until x>maxx;
end;

BEGIN
   flag := false;
   repeat
     clrscr;
     writeln('   --== MENU ==--');
     writeln('1. Input parameter function');
     writeln('2. Draw graph function');
     writeln('3. Exit');
     writeln;
     writeln('Choose point menu -> ');
     readln(punkt);
     case punkt of
     
  1:begin
           clrscr;
           repeat
             repeat
               writeln('Input min value x (radian) -> ');
               readln(s);
               val(s,minx,ercode);
               if (ercode <> 0) then
                 writeln('Error min value x!');
             until (ercode=0);
             repeat
               writeln('Input max value x (radian) -> ');
               readln(s);
               val(s,maxx,ercode);
               if (ercode <> 0) then
                 writeln('Error max value x !');
             until (ercode=0);
             if (minx>=maxx) then
               writeln('Min value x must be smaller max!');
           until (minx<maxx);


           repeat
             writeln('Input value a -> ');
             readln(s);
             val(s,a,ercode);
             if (ercode <> 0) then
               writeln('Error value a!');
           until (ercode=0);
           flag := true;

            repeat
             writeln('Input value b -> ');
             readln(s);
             val(s,a,ercode);
             if (ercode <> 0) then
               writeln('Error value b!');
           until (ercode=0);
           flag := true;
       end;


       2: begin

         if (flag) then
         begin
            if (grinit) then
            begin
               grminx:=48;
               grmaxx:=getmaxx-48;
               grminy:=getmaxy-48;
               grmaxy:=24;
               stepx:=(maxx-minx)/150;
               GetMaxMinY(miny,maxy);
               DrawMesh;
               DrawAxes;
               DrawGraphic;
               readkey;
               closegraph;
            end
         end
         else
           begin
              writeln('You need at the fist choose point 1 for value function!');
              readkey;
           end;
       end;
     end;
   until (punkt=3);
END.