//Função para controlar 8 Motores de passo através da Porta Paralela.
//Autor: Antonio Rogério Messias 
//www.rogercom.com
//rogercom@rogercom.com 
//Copyright(c) 1999-2004 ROGERCOM
//Todos os direitos reservados. 
//-------------------------------------------------------------------------------------------------------------------------------------------------------
#define LPT1 0x378
//Mascaras para manipular somente os Nibbles de uma palavra de 32 bits. 
#define MASK_NIBBLE_M1     0xFFFFFFF0 
#define MASK_NIBBLE_M2     0xFFFFFF0F
#define MASK_NIBBLE_M3     0xFFFFF0FF
#define MASK_NIBBLE_M4     0xFFFF0FFF
#define MASK_NIBBLE_M5     0xFFF0FFFF
#define MASK_NIBBLE_M6     0xFF0FFFFF
#define MASK_NIBBLE_M7     0xF0FFFFFF
#define MASK_NIBBLE_M8     0x0FFFFFFF

//Variáveis globais.
unsigned __int32 Dados;
char Passos[] = {1, 2, 4, 8}; //Passos simples.
unsigned char MAXPASSO = 3; //Máximo de passos: 0 a 3. 
//-------------------------------------------------------------------------------------------------------------------------------------------------------
//Função para enviar sinais para girar os motores através da Porta Paralela.
unsigned __int32 RotacionaMotor(unsigned __int32 BitsDados, int NumMotor, char Direcao)
{
   static short int IndexM1,IndexM2,IndexM3,IndexM4; 
   static short int IndexM5,IndexM6,IndexM7,IndexM8;
   String StBin; //Para armazenar a conversção da string binária. 
   if( Direcao == 'D' ) //Direita - Hórário.
   {
      switch( NumMotor ) //Escolhe qual o motor será girado.
      {
         case 1: if(IndexM1 > 0)
                        IndexM1--;
                     else
                        IndexM1 = MAXPASSO;
                     AnimaMotor1(IndexM1);
                     BitsDados = ( Passos[IndexM1] ) | (BitsDados & MASK_NIBBLE_M1);
                     break;
         case 2: if(IndexM2 > 0)
                        IndexM2--;
                     else
                        IndexM2 = MAXPASSO;

                     AnimaMotor2(IndexM2);
                     BitsDados = ( Passos[IndexM2]<<4 ) | (BitsDados & MASK_NIBBLE_M2);
                     break;
         case 3: if(IndexM3 > 0)
                        IndexM3--;
                     else
                        IndexM3 = MAXPASSO;
  
                     AnimaMotor3(IndexM3);
                     BitsDados = ( Passos[IndexM3]<<8 ) | (BitsDados & MASK_NIBBLE_M3);
                     break;
         case 4: if(IndexM4 > 0)
                        IndexM4--;
                     else
                        IndexM4 = MAXPASSO;

                     AnimaMotor4(IndexM4);
                     BitsDados = ( Passos[IndexM4]<<12 ) | (BitsDados & MASK_NIBBLE_M4);
                     break;

         case 5: if(IndexM5 > 0)
                        IndexM5--;
                     else
                        IndexM5 = MAXPASSO;

                     AnimaMotor5(IndexM5); 
                     BitsDados = ( Passos[IndexM5]<<16 ) | (BitsDados & MASK_NIBBLE_M5);
                     break;
         case 6: if(IndexM6 > 0)
                        IndexM6--;
                     else
                        IndexM6 = MAXPASSO;

                     AnimaMotor6(IndexM6);
                     BitsDados = ( Passos[IndexM6]<<20 ) | (BitsDados & MASK_NIBBLE_M6);
                     break;
         case 7: if(IndexM7 > 0)
                        IndexM7--;
                     else
                        IndexM7 = MAXPASSO;

                     AnimaMotor7(IndexM7);
                     BitsDados = ( Passos[IndexM7]<<24 ) | (BitsDados & MASK_NIBBLE_M7);
                     break;
         case 8: if(IndexM8 > 0)
                        IndexM8--;
                     else
                        IndexM8 = MAXPASSO;

                     AnimaMotor8(IndexM8);
                     BitsDados = ( Passos[IndexM8]<<28 ) | (BitsDados & MASK_NIBBLE_M8);
                     break;
      }
   }else if( Direcao == 'E' ) //Esquerda - Anti-horário.
   {
      switch( NumMotor )
      {
         case 1: if(IndexM1 < MAXPASSO)
                        IndexM1++;
                     else
                        IndexM1 = 0;

                     AnimaMotor1(IndexM1);
                     BitsDados = ( Passos[IndexM1] ) | (BitsDados & MASK_NIBBLE_M1);
                     break;
         case 2: if(IndexM2 < MAXPASSO)
                        IndexM2++;
                     else
                        IndexM2 = 0;

                     AnimaMotor2(IndexM2);
                     BitsDados = ( Passos[IndexM2]<<4 ) | (BitsDados & MASK_NIBBLE_M2);
                     break;
         case 3: if(IndexM3 < MAXPASSO)
                        IndexM3++;
                     else
                        IndexM3 = 0;

                     AnimaMotor3(IndexM3);
                     BitsDados = ( Passos[IndexM3]<<8 ) | (BitsDados & MASK_NIBBLE_M3);
                     break;
         case 4: if(IndexM4 < MAXPASSO)
                         IndexM4++;
                     else
                         IndexM4 = 0;

                     AnimaMotor4(IndexM4);
                     BitsDados = ( Passos[IndexM4]<<12 ) | (BitsDados & MASK_NIBBLE_M4);
                     break;
         case 5: if(IndexM5 < MAXPASSO)
                        IndexM5++;
                     else
                        IndexM5 = 0;

                     AnimaMotor5(IndexM5);
                     BitsDados = ( Passos[IndexM5]<<16 ) | (BitsDados & MASK_NIBBLE_M5);
                     break;
         case 6: if(IndexM6 < MAXPASSO)
                        IndexM6++;
                     else
                        IndexM6 = 0;

                     AnimaMotor6(IndexM6);
                     BitsDados = ( Passos[IndexM6]<<20 ) | (BitsDados & MASK_NIBBLE_M6);
                     break;
         case 7: if(IndexM7 < MAXPASSO)
                        IndexM7++;
                     else
                        IndexM7 = 0;      

                     AnimaMotor7(IndexM7);
                     BitsDados = ( Passos[IndexM7]<<24 ) | (BitsDados & MASK_NIBBLE_M7);
                     break;
         case 8: if(IndexM8 < MAXPASSO)
                        IndexM8++;
                     else
                        IndexM8 = 0;

                     AnimaMotor8(IndexM8); 
                     BitsDados = ( Passos[IndexM8]<<28 ) | (BitsDados & MASK_NIBBLE_M8);
                     break;
      }
   }
   Outport32(LPT1, BitsDados); //Envia os bits de controle para a porta paralela.
   StBin = StrBin32(BitsDados); //Converte inteiro em string binario.
   //Extrai cada Nibble e mostra na tela em binário.
   Form1->LabelNibbleM8->Caption = StBin.SubString(1, 4); 
   Form1->LabelNibbleM7->Caption = StBin.SubString(5, 4);
   Form1->LabelNibbleM6->Caption = StBin.SubString(9, 4);
   Form1->LabelNibbleM5->Caption = StBin.SubString(13, 4);
   Form1->LabelNibbleM4->Caption = StBin.SubString(17, 4);
   Form1->LabelNibbleM3->Caption = StBin.SubString(21, 4);
   Form1->LabelNibbleM2->Caption = StBin.SubString(25, 4);
   Form1->LabelNibbleM1->Caption = StBin.SubString(29, 4);
   return(BitsDados);
}