Duvida com código

[FABIO-2012]

Boa tarde amigos!

Estou precisando editar o código abaixo para que o mesmo funcione com banco de dados, mas como sou novo em delphi estou quebrando a cabeça sem saber como fazer isso, precisaria que algum coega do forum me desse umas dicxas de como fazer para implementar este código com BD

Basicamente ele manda informações para um microterminal, eu consegui fazer ele enviar informações e recebe-las em um memo ele pesquisa produto e usuário em DOIS arquivos texto respectivamente:

PRODUTO.TXT

VENDA.TXT

No caso eu deveria fazer com que ele me funcionasse para comanda eletrônica em PADARIA se algum amiogo já fez algo assim ou ao menos saiba implementar me ajude por gentileza

Copiei abaixo a unit do exemplo que vêm junto com o microterminal:

PS: A comunicação com o terminal esta funcionando ok

unit UTerminal;
 
interface
 
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
  Dialogs, ComCtrls, ExtCtrls, ScktComp, StdCtrls, ActnList, Buttons,
  ImgList, jpeg;
 
type
  PVendaItem = ^TVendaItem;
  TVendaItem = record
    idProduto: Integer;
    quantidade: Real;
    descricao: string[255];
    balancaRetorno: string[255];
    valor: Real;
    valorTotal: Real;
    pesar: Boolean;
  end;
 
  // PONTEIRO PARA CONTROLE E AÇÕES DOS TERMINAIS
  PTerminal = ^TTerminal;
  TTerminal = record
    IP: string; // ARMAZENAR IP DO TERMINAL
 
    tecla: string; // TECLA DIGITADA
    teclado: string; // BUFFER DO TECLADO
    delai: Integer; // CONTADOR DO DELAY DO TERMINAL
    estado: Integer; // PONTO DE EXECUÇÃO DO PROGRAMA
    estadoProximo: Integer; //USADO QUANDO TIVER DELAI
    tecladoAguardar: Boolean; // ESPERAR DIGITAÇÃO
    texto: string; // TEXTO DE ENTRADA
    textoPos: Integer; // POSIÇÃO DENTRO TEXTO QUE SERÁ RECEBIDO
    imprimir: Boolean;
 
    socket: TCustomWinSocket;
 
    // OPERADOR
    operadorID: Integer;
    operadorNome: string;
 
    // VENDA
    itens: TList; // LISTA DE ITENS COMPRADOS
    ValorTotal: Real; // VALOR TOTAL DA COMPRA
  end;
 
  TFTerminal = class(TForm)
    Panel1: TPanel;
    Bevel1: TBevel;
    servidor: TServerSocket;
    Panel2: TPanel;
    Splitter1: TSplitter;
    Bevel2: TBevel;
    edPorta: TEdit;
    Label1: TLabel;
    ActionList1: TActionList;
    actConecta: TAction;
    Timer1: TTimer;
    Memo1: TMemo;
    rgSerial: TRadioGroup;
    Label2: TLabel;
    Label3: TLabel;
    Panel3: TPanel;
    lstConexao: TListBox;
    Label4: TLabel;
    ImageList1: TImageList;
    actSair: TAction;
    SpeedButton2: TSpeedButton;
    Panel4: TPanel;
    Image1: TImage;
    Bevel3: TBevel;
    Label5: TLabel;
    Label6: TLabel;
    Label7: TLabel;
    Label8: TLabel;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure servidorClientConnect(Sender: TObject; Socket: TCustomWinSocket);
    procedure servidorClientDisconnect(Sender: TObject; Socket: TCustomWinSocket);
    procedure servidorClientRead(Sender: TObject; Socket: TCustomWinSocket);
    procedure Timer1Timer(Sender: TObject);
    procedure actSairExecute(Sender: TObject);
    procedure FormShow(Sender: TObject);
  private
    { Private declarations }
    // LISTA DE POINTEIROS DE TERMINAIS
    terminais: TList;
 
    // PROCEDURES PARA MANIPULACAO DE LISTA PONTEIROS
    procedure listaLimpar(xlista: TList);
 
    // PROCEDURES E FUNÇÕES PARA CONTROLE DE TERMINAIS
    function terminalCriar(xip: string): Pointer;
    procedure terminalDestruir(xterminal: Pointer);
    function terminalLocalizar(xip: string): Pointer;
 
    // MANIPULADORES DE SOCKET
    procedure servidorDesconectar;
    procedure servidorConectar;
 
    // MANIPULADORES DO TERMINAL
    // TECLADO
    function terminalTeclaTratar(xterminal: Pointer): Boolean; // TRATAR TECLA PRECIONADA NO TERMINAL
    procedure terminalTeclaPontoAjustar(xterminal: Pointer); // TESTA SE A TECLA PONTO FOI PRECIONADA
    procedure terminalGet(xterminal: Pointer; str: string);
    // DISPLAY DO TERMINAL
    procedure terminalDisplayPosicionar(xterminal: Pointer; xlinha, xcoluna: Byte);
    procedure terminalDisplayEnviar(xterminal: Pointer; xtexto: string);
    procedure terminalDisplayLimpar(xterminal: Pointer);
    // BALANCA
    procedure terminalBalanca(xterminal: Pointer);
    // IMPRIMIR
    procedure terminalImprimir(xterminal: Pointer; dados: string);
    // VARIAVEIS
    procedure terminalLimparVariaveis(xterminal: Pointer);
    // TRATAR ESTADO DO TERMINAL
    procedure terminalEstado(xterminal: Pointer);
 
    // PROCURAR USUARIO
    function usuarioGet(xidUsuario: Integer; var xnome: string): Boolean;
 
    // PROCURAR PRODUTO
    function produtoGet(xidProduto: Integer; var xdescricao: string; var xvalor: Real; var xpeso: Boolean): Boolean;
 
  public
    { Public declarations }
  end;
 
const
  // ESTADOS DO TERMINAL
 
  ESTADOOPERADOR = 10;
 
  ESTADOPRODUTO = 20;
 
  ESTADOFECHARVENDA = 90;
 
  ESTADOESPERAR = -1;
  ESTADOINICIAL = ESTADOOPERADOR;
  ESTADOFINAL = 9999;
 
  // NOMES DOS ARQUIVOS
  ARQUIVOUSUARIO = 'Usuario.txt';
  ARQUIVOPRODUTO = 'Produto.txt';
 
  // LAYOUT ARQUIVO USUARIO
  USUARIOCODFIM = 5;
  USUARIONOME = USUARIOCODFIM + 1;
 
  // LAYOUT O ARQUIVO DE PRODUTOS
  PRODUTOCODFIM = 5;
  PRODUTODESCRICAOINICIO = 7;
  PRODUTODESCRICAOQTD = 20;
  PRODUTOVALOR = 28;
  PRODUTOVALORQTD = 8;
  PRODUTOPESO = 37;
  PRODUTOPESOTAMANHO = 1;
var
  FTerminal: TFTerminal;
 
implementation
 
{$R *.dfm}
 
{ TFTerminal }
 
function TFTerminal.terminalCriar(xip: string): Pointer;
var
  wterminal: PTerminal;
begin
  Result := terminalLocalizar(xip);
 
  if Result = nil then
  begin
    New(wterminal);
    wterminal.IP := xip;
    wterminal.ValorTotal := 0;
    wterminal.itens := TList.Create;
    terminais.Add(wterminal);
 
    Result := wterminal;
  end;
end;
 
procedure TFTerminal.terminalDestruir(xterminal: Pointer);
begin
  ; // DESTRUIR O TERMINAL QUANDO O MESMO FOR DESCONECTADO
  if xterminal = nil then
    Exit;
 
  PTerminal(xterminal)^.socket := nil;
 
  ; // LIMPAR LISTA DE VENDAS
  listaLimpar(PTerminal(xterminal)^.itens);
 
  ; // DESTRUIR LISTA DE VENDAS
  FreeAndNil(PTerminal(xterminal)^.itens);
 
  ; // REMOVER TERMINAL DA LISTA DE TERMINAIS
  terminais.Delete(terminais.IndexOf(xterminal));
 
  ; // LIMPAR TERMIANL DA MEMORIA
  Dispose(xterminal);
end;
 
function TFTerminal.terminalLocalizar(xip: string): Pointer;
var
  i: Integer;
begin
  Result := nil;
 
  for i := 0 to terminais.Count - 1 do
  begin
    if PTerminal(terminais.Items[i])^.IP = xip then
      Result := terminais.Items[i];
  end;
end;
 
procedure TFTerminal.FormCreate(Sender: TObject);
begin
  ; // CRIAR LISTA DE TERMINAIS
  terminais := TList.Create;
end;
 
procedure TFTerminal.listaLimpar(xlista: TList);
var
  i: Integer;
begin
  if xlista = nil then
    Exit;
 
  for i := xlista.Count - 1 downto 0 do
  begin
    if xlista.Items[i] <> nil then
      Dispose(xlista.Items[i]);
  end;
 
  xlista.Clear;
end;
 
procedure TFTerminal.FormDestroy(Sender: TObject);
begin
  ; // DESETRUIR LISTA DE TERMINAIS
  servidorDesconectar;
  listaLimpar(terminais);
  FreeAndNil(terminais);
end;
 
procedure TFTerminal.servidorClientConnect(Sender: TObject;
  Socket: TCustomWinSocket);
begin
  lstConexao.Items.Add(Socket.RemoteAddress);
  Socket.Data := terminalCriar(Socket.RemoteAddress);
  PTerminal(Socket.Data)^.socket := Socket;
 
  terminalLimparVariaveis(Socket.Data);
  terminalEstado(Socket.Data);
end;
 
procedure TFTerminal.servidorClientDisconnect(Sender: TObject;
  Socket: TCustomWinSocket);
var
  widList: Integer;
begin
  terminalDestruir(Socket.Data);
 
  widList := lstConexao.Items.IndexOf(Socket.RemoteAddress);
 
  if widList >= 0 then
    lstConexao.Items.Delete(widList);
end;
 
procedure TFTerminal.servidorDesconectar;
var
  i: Integer;
begin
  with servidor do
  begin
    for i := Socket.ActiveConnections - 1 downto 0 do
    begin
      with servidor.Socket.Connections[i] do
      begin
        terminalDisplayLimpar(Data);
        terminalDisplayEnviar(Data, 'SERVIDOR DESCONECTADO');
        terminalDestruir(Data);
      end;
 
    end;
 
    lstConexao.Items.Clear;
 
    actConecta.ImageIndex := 0;
    actConecta.Hint := 'Conectar';
 
       Close;
  end;
end;
 
procedure TFTerminal.servidorConectar;
begin
  with servidor do
  begin
    Port := StrToInt(edPorta.Text);
    actConecta.ImageIndex := 1;
    actConecta.Hint := 'Desconectar';
    Open;
  end;
end;
 
procedure TFTerminal.terminalDisplayEnviar(xterminal: Pointer; xtexto: string);
begin
  ; // ENVIAR TEXTO PARA O TERMINAL
  with PTerminal(xterminal)^ do
  begin
    socket.SendText(xtexto);
  end;
end;
 
procedure TFTerminal.terminalDisplayPosicionar(xterminal: Pointer; xlinha,
  xcoluna: Byte);
var
  StrTemp: string;
begin
  StrTemp := Chr(27) + '[' + FormatFloat('00', xlinha) + ';' + FormatFloat('00', xcoluna) + 'H';
  with PTerminal(xterminal)^ do
  begin
    Socket.SendText(StrTemp);
  end;
end;
 
procedure TFTerminal.terminalDisplayLimpar(xterminal: Pointer);
begin
  with PTerminal(xterminal)^ do
  begin
    socket.SendText(#27'[H'#27'[J');
    terminalDisplayPosicionar(xterminal, 1, 1);
  end;
end;
 
function TFTerminal.terminalTeclaTratar(xterminal: Pointer): Boolean;
// TRATAR TECLA PRECIONADA NO TERMINAL
var
  gpict: string;
  tamanho: Integer;
begin
  with PTerminal(xterminal)^ do
  begin
 
    if tecla = Chr(0) then
    begin
      Result := False;
      Exit;
    end;
 
    ; // TECLA DEL PRECIONADA
    if tecla = Chr(27) then
    begin
      if textoPos = 1 then
      begin
        teclado := Chr(27);
        tecladoAguardar := False;
        Result := True;
      end
      else
      begin
        while textoPos > 1 do
        begin
          tecla := Chr(8) + Chr(16) + Chr(8); // BACKSPACE
          terminalDisplayEnviar(xterminal, tecla);
          textoPos := textoPos - 1;
        end;
        teclado := '';
        Result := False;
      end;
      Exit;
    end;
 
 
    if tecla = Chr(8) then // BACKSPACE
    begin
      if textoPos > 1 then
      begin
        gpict := Copy(texto, textoPos - 1, 1);
        if (gpict = '/') or (gpict = '.') then
        begin
          terminalDisplayEnviar(xterminal, Tecla);
          textoPos := textoPos - 1;
        end;
        textoPos := textoPos - 1;
        teclado := copy(teclado, 1, textoPos - 1);
        tecla := tecla + ' ' + Chr(8);
        terminalDisplayEnviar(xterminal, Tecla);
      end;
      Result := False;
      Exit;
    end;
 
    if tecla = Chr(13) then // ENTER
    begin
      tecladoAguardar := false;
      Result := true;
      Exit;
    end;
 
    gpict := copy(texto, textoPos, 1);
 
    ; // PEDIDO DE PESO
    if gpict = #3 then
    begin
      ; // todo peso foi recebido
      if Tecla = #3 then
      begin
        tecladoAguardar := False;
        Result := True;
        Exit;
      end
      else
      begin
        ; // PROTOCOLO DA BALANÇA <STX> PPPPP <ETX>
        if (tecla <> #2) and (tecla <> #3) then
          teclado := teclado + tecla;
      end;
    end;
 
    if gpict = 'X' then // QUALQUER TECLA
    begin
      teclado := teclado + tecla;
      textoPos := textoPos + 1;
      terminalDisplayEnviar(xterminal, Tecla);
    end
    else if gpict = '9' then // SOMENTE ACEITAR NUMEROS E "." OU "/" OU "-"
    begin
      if ((Tecla[1] in ['0'..'9'])) or (Tecla = '.') or (Tecla = '/') or (Tecla = '-') then
      begin
        if Tecla = '.' then begin
          terminalTeclaPontoAjustar(xterminal);
        end
        else
        begin
          teclado := teclado + tecla;
          textoPos := textoPos + 1;
          terminalDisplayEnviar(xterminal, tecla);
        end;
      end;
    end
    else
    begin
      if gpict = 'A' then // Somente teclas alfabéticas
      begin
        if tecla[1] in ['A'..'Z'] then
        begin
          teclado := teclado + tecla;
          textoPos := textopos + 1;
          terminalDisplayEnviar(xterminal, Tecla);
        end;
      end
      else
        if gpict = '*' then // Digitação de senha
        begin
          if tecla[1] in ['0'..'9'] then // caso apenas número
          begin
            teclado := teclado + tecla;
            textoPos := textoPos + 1;
            tecla := '*';
            terminalDisplayEnviar(xterminal, tecla);
          end;
        end
        else
        begin
          Result := False;
          Exit;
        end;
    end;
 
    tamanho := Length(texto) + 1;
    gpict := copy(texto, textoPos, 1);
 
    if tamanho = textoPos then
    begin
      Result := true;
      tecladoAguardar := False;
    end
    else
    begin
      if gpict = '/' then
      begin
        tecla := '/';
        textoPos := textoPos + 1;
        terminalDisplayEnviar(xterminal, Tecla);
        Result := False;
      end
      else
        if gpict = '.' then
        begin
          tecla := '.';
          textoPos := textoPos + 1;
          terminalDisplayEnviar(xterminal, Tecla);
          Result := False;
        end
        else
        begin
          Result := False;
        end;
    end;
  end;
end;
 
procedure TFTerminal.terminalTeclaPontoAjustar(xterminal: Pointer);
// TESTA SE A TECLA PONTO FOI PRECIONADA
var
  PosPonto: integer;
  StrDisp: string;
  spPic: integer;
begin
  with PTerminal(xterminal)^ do
  begin
    PosPonto := 1;
    while (copy(texto, PosPonto, 1) <> '.') do
    begin
      PosPonto := PosPonto + 1;
      if PosPonto = length(texto) then
      begin
        Exit;
      end;
    end;
    if PosPonto = length(texto) then
    begin
      exit;
    end;
    spPic := PosPonto - 1 - length(texto);
    StrDisp := '';
    while spPic > 0 do
    begin
      StrDisp := StrDisp + ' ';
      spPic := spPic - 1;
    end;
    strdisp := strdisp + teclado;
    sppic := textoPos;
    while sppic > 1 do
    begin
      terminalDisplayEnviar(xterminal, chr(8));
      sppic := sppic - 1;
    end;
    textoPos := posponto;
    terminalDisplayEnviar(xterminal, strdisp);
    teclado := strdisp;
  end;
end;
 
procedure TFTerminal.terminalLimparVariaveis(xterminal: Pointer);
begin
  with PTerminal(xterminal)^ do
  begin
    textoPos := 0;
    estado := ESTADOINICIAL;
    estadoProximo := -2;
    tecladoAguardar := False;
    delai := 0;
 
    operadorID := 0;
    operadorNome := '';
 
    ValorTotal := 0;
 
    listaLimpar(itens);
  end;
end;
 
procedure TFTerminal.terminalGet(xterminal: Pointer; str: string);
begin
  with PTerminal(xterminal)^ do
  begin
    if not tecladoAguardar then
    begin
      tecladoAguardar := true;
      textoPos := 1;
      texto := str;
      teclado := '';
    end;
  end;
end;
 
procedure TFTerminal.terminalBalanca(xterminal: Pointer);
begin
  with PTerminal(xterminal)^ do
  begin
    socket.SendText(#27 + '[?24h' + #27 + '[5i' + #5 + #27 + '[4i'); //Serial 1 para MT TCP
 
    // socket.SendText(Chr(27) + '[?24r' + Chr(27) + '[5i' + Chr(5) + Chr(27) + '[4i');// serial 0 para MT TCP
  end;
end;
 
procedure TFTerminal.terminalImprimir(xterminal: Pointer; dados: string);
begin
  with PTerminal(xterminal)^ do
  begin
    if not imprimir then
    begin
      Memo1.Lines.Add(dados);
    end
    else
    begin
      case rgSerial.ItemIndex of
        0:
          begin
            socket.SendText(#27 + '[?24h' + #27 + '[5i' + Dados + #27 + '[4i');
          end;
        1:
          begin
            socket.SendText(#27 + '[?24r' + #27 + '[5i' + Dados + #27 + '[4i');
          end;
        2:
          begin
            socket.SendText(#27 + '[?24l' + #27 + '[5i' + Dados + #27 + '[4i');
          end;
      end;
    end;
  end;
end;
 
procedure TFTerminal.terminalEstado(xterminal: Pointer);
var
  prodDesc: string;
  prodValor: Real;
  prodPesar: Boolean;
  waux, waux1: string;
  wproduto: PVendaItem;
  i, cod: Integer;
begin
  ; // TRATAR ESTADO DO TERMINAL
  if xterminal = nil then
    Exit;
 
  with PTerminal(xterminal)^ do
  begin
    case estado of
      ESTADOESPERAR:
        begin
          ; // AGUARDAR UMA RESPOSTA ( DELAI )
          estado := estadoProximo;
          estadoProximo := -2;
        end;
 
      ESTADOOPERADOR:
        begin
          ; // PEDIR OPERADOR NA TELA DO TERMINAL
          terminalDisplayLimpar(xterminal);
          terminalDisplayEnviar(xterminal, 'OPERADOR:');
          terminalGet(xterminal, '****');
          estado := estado + 1;
        end;
 
      ESTADOOPERADOR + 1:
        begin
          ; // VALIDAR OPERADOR
          if terminalTeclaTratar(xterminal) then
          begin
            if (teclado = '') or (teclado = #27) then
            begin
              estado := ESTADOOPERADOR
            end
            else
            begin
              ; // PROCURAR USUÁRIO NO ARQUIVO TEXTO
              ; // AQUI VOCÊ PODE TAMBÉM OLOCAR SUA CONSULTA NO BANCO DE DADOS
              if usuarioGet(StrToInt('0' + teclado), operadorNome) then
              begin
                estado := ESTADOPRODUTO;
              end
              else
              begin
                teclado := '';
                terminalDisplayLimpar(xterminal);
                terminalDisplayEnviar(xterminal, 'OPERADOR NAO');
                terminalDisplayPosicionar(xterminal, 2, 1);
                terminalDisplayEnviar(xterminal, 'ENCONTRADO');
                estado := ESTADOESPERAR;
                estadoProximo := ESTADOOPERADOR;
                delai := 3;
              end;
            end;
          end;
        end;
 
      ESTADOPRODUTO:
        begin
          ; // PEDIR CÓDIGO DO PRODUTO
          terminalDisplayLimpar(xterminal);
          terminalDisplayEnviar(xterminal, 'V.TOTAL: ' + FormatFloat('0.00', ValorTotal));
          terminalDisplayPosicionar(xterminal, 2, 1);
          terminalDisplayEnviar(xterminal, 'PRODUTO: ');
          terminalGet(xterminal, '99999');
          estado := estado + 1;
        end;
 
      ESTADOPRODUTO + 1:
        begin
          ; // VALIDAR PRODUTO
          if terminalTeclaTratar(xterminal) then
          begin
            if (teclado = '') then
            begin
              if tecla[1] = #13 then
              begin
                ; // VERIFICAR SE FECHA A VENDA
                if itens.Count >= 1 then
                  estado := ESTADOFECHARVENDA // FECHAR A VENDA
                else
                  estado := ESTADOPRODUTO; // CONTINUAR EM PRODUTOS
              end
              else
              begin
                estado := ESTADOPRODUTO;
              end;
            end
            else if (teclado = #27) then
            begin
              ; // CANCELAR A VENDA
              ValorTotal := 0;
              operadorID := 0;
              operadorNome := '';
              listaLimpar(itens);
              estado := ESTADOOPERADOR;
            end
            else
            begin
              ; // PROCURAR PRODUTO NO ARQUIVO TEXTO
              ; // AQUI VOCÊ PODE TAMBÉM OLOCAR SUA CONSULTA NO BANCO DE DADOS
              if produtoGet(StrToInt('0' + teclado), prodDesc, prodValor, prodPesar) then
              begin
                ; // ACRECESNTAR PRODUTO NA LISTA DE VENDA
                New(wproduto);
                wproduto.idProduto := StrToInt('0' + teclado);
                wproduto.valor := prodValor;
                wproduto.descricao := prodDesc;
                wproduto.pesar := prodPesar;
                PTerminal(xterminal)^.itens.Add(wproduto);
 
                ; // VERIFICAR SE O PRODUTO É DE PESAR OU NÃO
                if wproduto.pesar then
                begin
                  ; // SOLICITAR PESO PARA A BALANÇA
                  terminalGet(xterminal, #3);
                  estado := ESTADOPRODUTO + 4;
                end
                else
                begin
                  ; // SOLICITAR QUANTIDADE DE PRODUTOS
                  estado := ESTADOPRODUTO + 2;
                end;
              end
              else
              begin
                ; // PRODUTO NÃO ENCONTRADO
                teclado := '';
                terminalDisplayLimpar(xterminal);
                terminalDisplayEnviar(xterminal, 'PRODUTO NAO');
                terminalDisplayPosicionar(xterminal, 2, 1);
                terminalDisplayEnviar(xterminal, 'ENCONTRADO');
                estado := ESTADOESPERAR;
                estadoProximo := ESTADOPRODUTO;
                delai := 3;
              end;
            end;
          end;
        end;
 
      ESTADOPRODUTO + 2:
        begin
          ; // PEDIR QUANTIDADE DE PRODUTOS
          delai := 0;
          terminalDisplayLimpar(xterminal);
          terminalDisplayEnviar(xterminal, PVendaItem(itens.Items[itens.Count - 1])^.descricao);
          terminalDisplayPosicionar(xterminal, 2, 1);
          terminalDisplayEnviar(xterminal, 'QTD: ');
          terminalGet(xterminal, '9999999');
          estado := estado + 1;
        end;
 
      ESTADOPRODUTO + 3:
        begin
          if terminalTeclaTratar(xterminal) then
          begin
            if (teclado = '') then
            begin
              estado := ESTADOPRODUTO + 2;
            end
            else if (teclado = #27) then
            begin
              Dispose(itens.Items[itens.Count - 1]);
              itens.Delete(itens.Count - 1);
              estado := ESTADOPRODUTO;
            end
            else
            begin
              with PVendaItem(itens.Items[itens.Count - 1])^ do
              begin
                quantidade := StrToFloat('0' + teclado);
                valorTotal := valor * quantidade;
              end;
 
              ValorTotal := ValorTotal +
                PVendaItem(itens.Items[itens.Count - 1])^.valorTotal;
 
              estado := ESTADOPRODUTO;
            end;
          end;
        end;
 
      ESTADOPRODUTO + 4:
        begin
          ; // SOLICITAR PESO PARA BALANÇA
          terminalDisplayLimpar(xterminal);
          terminalDisplayEnviar(xterminal, 'AGUARDANDO PESO...');
          teclado := '';
          terminalBalanca(xterminal);
          estado := estado + 1;
          delai := 4;
        end;
 
      ESTADOPRODUTO + 5:
        begin
          if terminalTeclaTratar(xterminal) then
          begin
            if teclado = '' then
            begin
              terminalGet(xterminal, Chr(3));
              estado := ESTADOPRODUTO + 4;
              delai := 4;
            end
            else
            begin
              with PVendaItem(itens.Items[itens.Count - 1])^ do
              begin
                balancaRetorno := teclado;
                waux := Copy(Trim(teclado), 1, 2);
                waux1 := Copy(Trim(teclado), 3, 3);
 
                Val(waux + '.' + waux1, quantidade, cod);
 
                valorTotal := valor * quantidade;
 
                ValorTotal := ValorTotal +
                  PVendaItem(itens.Items[itens.Count - 1])^.valorTotal;
              end;
 
              estado := ESTADOPRODUTO;
            end;
          end
          else
          begin
            if delai <= 0 then
            begin
              teclado := '';
              terminalBalanca(xterminal);
              delai := 4;
            end;
          end;
        end;
 
      ESTADOFECHARVENDA:
        begin
          terminalDisplayLimpar(xterminal);
          terminalDisplayEnviar(xterminal, 'IMPRIMIR ?');
          terminalDisplayPosicionar(xterminal, 2, 1);
          terminalDisplayEnviar(xterminal, '1-SIM      2-NAO');
          terminalGet(xterminal, '9');
          estado := estado + 1;
        end;
 
      ESTADOFECHARVENDA + 1:
        begin
          if terminalTeclaTratar(xterminal) then
          begin
            if (teclado = '') then
            begin
              estado := ESTADOFECHARVENDA;
            end
            else if (teclado = #27) or (teclado = '2') then
            begin
              imprimir := False;
              teclado := '';
              estado := estado + 1;
            end
            else
            begin
              imprimir := True;
              estado := estado + 1; ;
            end;
          end;
        end;
 
      ESTADOFECHARVENDA + 2:
        begin
          terminalDisplayLimpar(xterminal);
          terminalDisplayEnviar(xterminal, 'VENDA FINALIZADA');
 
          Memo1.Lines.Clear;
 
          terminalImprimir(xterminal, 'OPERADOR: ' + operadorNome);
          terminalImprimir(xterminal, '');
          for i := 0 to itens.Count - 1 do
          begin
            with PVendaItem(itens.Items[i])^ do
            begin
              if pesar then
              begin
                terminalImprimir(xterminal,
                  descricao + ' - ' +
                  FormatFloat('0.000 kg', quantidade) + ' - ' +
                  balancaRetorno + ' - ' +
                  FormatFloat('R$ 0.00', valor) + ' - ' +
                  FormatFloat('R$ 0.00', valorTotal)
                  );
              end
              else
              begin
                terminalImprimir(xterminal,
                  descricao + ' - ' +
                  FormatFloat('0', quantidade) + ' - ' +
                  FormatFloat('R$ 0.00', valor) + ' - ' +
                  FormatFloat('R$ 0.00', valorTotal)
                  );
              end;
            end;
          end;
          terminalLimparVariaveis(xterminal);
          estado := ESTADOINICIAL;
        end;
 
      ESTADOFINAL:
        begin
          if terminalTeclaTratar(xterminal) then
          begin
            terminalLimparVariaveis(xterminal);
            estado := ESTADOINICIAL;
          end;
        end;
 
    end;
  end;
end;
 
procedure TFTerminal.servidorClientRead(Sender: TObject;
  Socket: TCustomWinSocket);
var
  StrTemp: string;
  wterminal: Pointer;
  i: Integer;
begin
  StrTemp := UpperCase(Socket.ReceiveText);
  wterminal := Socket.Data;
 
  if wterminal <> nil then
  begin
    with PTerminal(wterminal)^ do
    begin
      for i := 1 to Length(StrTemp) do
      begin
        tecla := copy(StrTemp, I, 1);
        terminalEstado(wterminal);
      end;
 
      tecla := Chr(0); // TECLA NULA
      terminalEstado(wterminal); // CHAMAR TRATAMENTO DE TECLAS PARA ATUALIZÇÃO DE TELA DO TERMINAL
    end;
  end;
end;
 
function TFTerminal.usuarioGet(xidUsuario: Integer;
  var xnome: string): Boolean;
var
  widusuario: string;
  warquivo: TStringList;
  i: Integer;
begin
  try
    widusuario := FormatFloat('00000', xidUsuario);
    warquivo := TStringList.Create;
    warquivo.LoadFromFile(ARQUIVOUSUARIO);
 
    for i := 0 to warquivo.Count - 1 do
    begin
      Result := Pos(widusuario, warquivo[i]) > 0;
      if Result then
      begin
        xnome := Trim(Copy(warquivo[i], USUARIONOME, Length(warquivo[i]) - USUARIOCODFIM));
        Break;
      end;
    end;
  finally
    FreeAndNil(warquivo);
  end;
end;
 
function TFTerminal.produtoGet(xidProduto: Integer; var xdescricao: string;
  var xvalor: Real; var xpeso: Boolean): Boolean;
var
  widProduto, wvalor: string;
  wvalorReal: Real;
  warquivo: TStringList;
  i, cod: Integer;
begin
  try
    widProduto := FormatFloat('00000', xidProduto);
    warquivo := TStringList.Create;
    warquivo.LoadFromFile(ARQUIVOPRODUTO);
 
    for i := 0 to warquivo.Count - 1 do
    begin
      Result := Pos(widProduto, warquivo[i]) > 0;
      if Result then
      begin
        xdescricao := Trim(Copy(warquivo[i], PRODUTODESCRICAOINICIO, PRODUTODESCRICAOQTD));
 
        wvalor := Trim(Copy(warquivo[i], PRODUTOVALOR, PRODUTOVALORQTD));
 
        Val(Trim(wvalor), wvalorReal, cod);
 
        xvalor := wvalorReal;
 
        xpeso :=
          Trim(Copy(warquivo[i], PRODUTOPESO, Length(warquivo[i]) - PRODUTOPESOTAMANHO)) = '1';
        Break;
      end;
    end;
  finally
    FreeAndNil(warquivo);
  end;
end;
 
procedure TFTerminal.Timer1Timer(Sender: TObject);
var
  i: Integer;
begin
  for I := 0 to Servidor.Socket.ActiveConnections - 1 do
  begin
    if Servidor.Socket.Connections[i].Data <> nil then
    begin
      with PTerminal(Servidor.Socket.Connections[i].Data)^ do
      begin
        if delai > 0 then
        begin
          delai := delai - 1;
          if delai <= 0 then
          begin
            terminalEstado(Servidor.Socket.Connections[i].Data);
          end;
        end;
      end;
    end;
  end;
end;
 
procedure TFTerminal.actSairExecute(Sender: TObject);
begin
  Application.Terminate;
end;
 
procedure TFTerminal.FormShow(Sender: TObject);
begin
servidor.Port:=1001;
servidor.Active:=true;
end;
 
end.

[Jhonas]

veja se encontra o que precisa nesse link ...

http://www.gertec.com.br/Site.aspx/DriversManuaisSoftwares?qsTipoArquivo=7OddVzA6kuw=&qsCodigoProduto=Jo/dZOnD9ZY=

tem 1 exemplo para restaurante em varias linguagens e um em delphi

mesmo que o seu microterminal não seja esse, a logica do programa é a mesma

================================================================================

Basicamente ele manda informações para um microterminal, eu consegui fazer ele enviar informações e recebe-las em um memo ele pesquisa produto e usuário em DOIS arquivos texto respectivamente:

imagine que esse memo seja um campo de sua tabela .... voce vai usa-lo como se estivesse trabalhando sem o microterminal

voce vai acessar a tabela, vai ler, ou gravar nesse campo memo ....(necessariamente não precisa ser um campo memo )

poderia te ajudar mais com o seu código, se eu tivesse um microterminal para testa-lo .... mas aparentemente a sua lógica esta correta

abraço

[FABIO-2012]

Obrigado amigo, mas você poderia pelo menos me mostrar em meu código como você faria? Já seria assim de muita ajuda ele esta funcionando mas eu queria apenas entyender aonde colocaria os campos porque qualquer erro recorrente de não ter o microterminal eu conseguiria resolver aqui, meu problema é não conseguir c compreender o código em um todo, se puder fazer isso será muito bom

[Jhonas]

ok... vamos tentar, mas sem o microterminal para testar, fica a seu cargo resolver os problemas

como usar um banco de dados com o microterminal

veja essa função

function TFTerminal.produtoGet(xidProduto: Integer; var xdescricao: string;
var xvalor: Real; var xpeso: Boolean): Boolean;
var
widProduto, wvalor: string;
wvalorReal: Real;
warquivo: TStringList;
i, cod: Integer;
begin
try
widProduto := FormatFloat('00000', xidProduto);
warquivo := TStringList.Create;
warquivo.LoadFromFile(ARQUIVOPRODUTO);

for i := 0 to warquivo.Count - 1 do
begin
Result := Pos(widProduto, warquivo) > 0;
if Result then
begin
xdescricao := Trim(Copy(warquivo, PRODUTODESCRICAOINICIO, PRODUTODESCRICAOQTD));

wvalor := Trim(Copy(warquivo, PRODUTOVALOR, PRODUTOVALORQTD));

Val(Trim(wvalor), wvalorReal, cod);

xvalor := wvalorReal;

xpeso :=
Trim(Copy(warquivo, PRODUTOPESO, Length(warquivo) - PRODUTOPESOTAMANHO)) = '1';
Break;
end;
end;
finally
FreeAndNil(warquivo);
end;
end;

aqui nessa parte começa a leitura do arquivo texto que é passado para um TStringList

widProduto := FormatFloat('00000', xidProduto);
warquivo := TStringList.Create;
warquivo.LoadFromFile(ARQUIVOPRODUTO);

se voce usar um banco de dados, voce deve criar uma tabela com o nome PRODUTOS e definir os campos

obs: isso é apenas um exemplo de como voce deve implementar o banco de dados

idProduto Integer 10;

descricao string 30;
valor numeric(11,2);

peso Boolean;

se voce for sar o componente TQUERY, ficaria assim:

Query1.Active := false;

Query1.SQL.Clear;

Query1.SQL.Append('select * from tabela where idProduto = 100'); // aqui voce pode passar um parametro para a select

Query1.Active := true;

nesse ponto a sua pesquisa já foi feita e o resultado será os campos do produto que tem o id = 100

a partir disso, voce pode pegar os valores dos campos e retornar para o microterminal, não precisando usar o

for i := 0 to warquivo.Count - 1 do //// para procurar nas linhas de texto do warquivo: TStringList;

então ficaria algo parecido com isso:

function TFTerminal.produtoGet(xidProduto: Integer; var xdescricao: string;
var xvalor: Real; var xpeso: Boolean): Boolean;
var
widProduto, wvalor: string;
wvalorReal: Real;
warquivo: TStringList;
i, cod: Integer;
begin
try

Query1.Active := false;

Query1.SQL.Clear;

Query1.SQL.Append('select * from tabela where idProduto = 100'); // aqui voce pode passar um parametro para a select

Query1.Active := true;

xdescricao := Trim(Query1Descricao.Value);

wvalor := Trim(Query1Valor.Value);

xvalor := wvalorReal;

xpeso := True;

Break;
end;
end;
finally

end;
end;

OBS: O código é apenas um exempo para lhe mostrar como usar uma tabela ... resta a voce entender a lógica e fazer testes no seu código ( não esqueça de fazer uma cópia antes de mexer nele )

abraço