//Version: v0.11
// written by Florian Strunk
// License: GPL

#include "vc920_960.h"
#include <string.h>

int digit(int x)
{
	int dig1[10]={0x30,0x31,0x32,0x33,0x34,0x35, 0x36,0x37,0x38, 0x39};
        int n;
	for(n=0;n<10;n++)
		if (x==dig1[n])
			return n;
	return 0;
}


void setSTATE_ACDC(unsigned char byte7, struct dvm_data *pdvmdata)
{
  switch (byte7)
  {
    case 0x00: strcpy((*pdvmdata).STATE_ACDC,"OFF"); break;

    case 0x01: strcpy((*pdvmdata).STATE_ACDC,"AC"); break;

    case 0x02: strcpy((*pdvmdata).STATE_ACDC,"DC"); break;

    case 0x03: strcpy((*pdvmdata).STATE_ACDC,"AC+DC");break;

    default: strcpy((*pdvmdata).STATE_ACDC,"");
  }
}

void setSTATE_AUTO(unsigned char byte8, struct dvm_data *pdvmdata)
{
  byte8 = byte8 & 0x03; //Vorzeichen aus Byte entfernen
  switch (byte8)
  {
    case 0x00: strcpy((*pdvmdata).STATE_ACDC,"OFF"); break;

    case 0x01: strcpy((*pdvmdata).STATE_ACDC,"AUTO"); break;

    case 0x02: strcpy((*pdvmdata).STATE_ACDC,"Manual"); break;

    case 0x03: strcpy((*pdvmdata).STATE_ACDC,"AC+DC");break;

    default: strcpy((*pdvmdata).STATE_ACDC,"");
  }
}
int isOverload(unsigned char* in)
{
  if ((in[0]==0x3a) && (in[1]==0x3a) && (in[2]==0x30) && (in[3]==0x3c) && (in[4]==0x3a))
  {
     return 1;
  }
  return 0;
}

void dvm_unit(unsigned char byte5, unsigned char byte6, unsigned char byte8, struct dvm_data *pdvmdata)
{	
	char *prefix="";
	char *unit="";
	char *ext="";
	char *ext1="";
        char *sign="";
   struct dvm_data *dvmdata = pdvmdata;
   //struct Tparameter_log para = *((struct Tparameter_log*) arg);
   //byte8 vorzeichen
   //2. Teil 0xxx -> +; 1xxx -> -;
   unsigned char tempsign = 0;
   tempsign = byte8 & 0x04;
   if (tempsign == 0x04)
    { strcpy((*dvmdata).sign,"-");}
   else { strcpy((*dvmdata).sign,"+");}


   switch (byte6){

   // AC mV (2. Teil des Bytes = 0)
   case 0x30:
      {
        strcpy((*dvmdata).type,"AC_mV");
        strcpy((*dvmdata).unit,"V");
        strcpy((*dvmdata).prefix,"m");
        (*dvmdata).divisor = 100;
        break;
      }
   
   // DCV
   case 0x31:
      {
        strcpy((*dvmdata).type,"DC_V");
        strcpy((*dvmdata).unit,"V");
        strcpy((*dvmdata).prefix,"");
        switch (byte5)
        {
           case 0x30:(*dvmdata).divisor = 100000;
                    break;

           case 0x31: (*dvmdata).divisor = 10000;
                    break;

           case 0x32: (*dvmdata).divisor = 1000;
                    break;

           case 0x33: (*dvmdata).divisor = 100;
                    break;

           case 0x34: (*dvmdata).divisor = 10;
                    break;
        
        }
        break;
      }

   // ACV
   case 0x32:
      {
        strcpy((*dvmdata).type,"AC_V");
        strcpy((*dvmdata).unit,"V");
        strcpy((*dvmdata).prefix,"");
        switch (byte5)
        {
           case 0x30: (*dvmdata).divisor = 100000;
                    break;

           case 0x31: (*dvmdata).divisor = 10000;
                    break;

           case 0x32: (*dvmdata).divisor = 1000;
                    break;

           case 0x33: (*dvmdata).divisor = 100;
                    break;

           case 0x34: (*dvmdata).divisor = 10;
                    break;
        
        }
        break;
      }
   // DCmV
   case 0x33:
      {
        strcpy((*dvmdata).type,"DC_mV");
        strcpy((*dvmdata).unit, "V");
        strcpy((*dvmdata).prefix, "m");
        switch (byte5)
        {
           case 0x30: (*dvmdata).divisor = 100;
                    break;
        }
        break;
      }

   // Ohm
   case 0x34:
      {
        strcpy((*dvmdata).type,"Ohm");
        strcpy((*dvmdata).unit, "Ohm");
        
        switch (byte5)
        {
           case 0x31: (*dvmdata).divisor = 100;
			strcpy((*dvmdata).prefix, "");
                    break;
           case 0x32:  (*dvmdata).divisor = 10000;
			strcpy((*dvmdata).prefix, "k");
                    break;
           case 0x33:  (*dvmdata).divisor = 1000;
			strcpy((*dvmdata).prefix, "k");
                    break;
           case 0x34:  (*dvmdata).divisor = 100;
			strcpy((*dvmdata).prefix, "k");
                    break;
           case 0x35:  (*dvmdata).divisor = 10000;
			strcpy((*dvmdata).prefix, "M");
                    break;
           case 0x36:  (*dvmdata).divisor = 1000;
			strcpy((*dvmdata).prefix, "M");
                    break;
        }
     break;
     }

   // C
   case 0x35:
      {
        strcpy((*dvmdata).type,"C");
        strcpy((*dvmdata).unit, "C");
        
        switch (byte5)
        {
           case 0x31: (*dvmdata).divisor = 1000;
			strcpy((*dvmdata).prefix, "n");
                    break;
           case 0x32:  (*dvmdata).divisor = 100;
			strcpy((*dvmdata).prefix, "n");
                    break;
           case 0x33:  (*dvmdata).divisor = 10000;
			strcpy((*dvmdata).prefix, "n");
                    break;
           case 0x34:  (*dvmdata).divisor = 1000;
			strcpy((*dvmdata).prefix, "u");
                    break;
           case 0x35:  (*dvmdata).divisor = 100;
			strcpy((*dvmdata).prefix, "u");
                    break;
           case 0x36:  (*dvmdata).divisor = 10000;
			strcpy((*dvmdata).prefix, "m");
                    break;
           case 0x37:  (*dvmdata).divisor = 1000;
			strcpy((*dvmdata).prefix, "m");
                    break;
        }
      break;
      }

   // Temperatur Grad C
   case 0x36:
      {
        strcpy((*dvmdata).type,"Temperature");
        strcpy((*dvmdata).unit, "°C");
        
        switch (byte5)
        {
           case 0x30: (*dvmdata).divisor = 10;
			strcpy((*dvmdata).prefix, "");
                    break;
        }
       break;
       }

   // uA
   case 0x37:
      {
        strcpy((*dvmdata).type,"uA");
        strcpy((*dvmdata).unit, "A");
        
        switch (byte5)
        {
           case 0x30: (*dvmdata).divisor = 100;
			strcpy((*dvmdata).prefix, "u");
                    break;
        
           case 0x31: (*dvmdata).divisor = 10;
			strcpy((*dvmdata).prefix, "u");
                    break;
        }
       break;
       }

   // mA
   case 0x38:
      {
        strcpy((*dvmdata).type,"mA");
        strcpy((*dvmdata).unit, "A");
        
        switch (byte5)
        {
           case 0x30: (*dvmdata).divisor = 1000;
			strcpy((*dvmdata).prefix, "m");
                    break;
        
           case 0x31: (*dvmdata).divisor = 100;
			strcpy((*dvmdata).prefix, "m");
                    break;
        }
       break;
       }

   // A
   case 0x39:
      {
        strcpy((*dvmdata).type,"10A");
        strcpy((*dvmdata).unit, "A");
        
        switch (byte5)
        {
           case 0x30: (*dvmdata).divisor = 1000;
			strcpy((*dvmdata).prefix, "");
                    break;
        }
      break;
      }

  // Fm
   case 0x3A:
      {
        strcpy((*dvmdata).type,"Fm");
        strcpy((*dvmdata).unit, "Fm");
        
        switch (byte5)
        {
           case 0x30: (*dvmdata).divisor = 1;
			strcpy((*dvmdata).prefix, "");
                    break;
        }
      break;
      }

   // Diode
   case 0x3B:
      {
        strcpy((*dvmdata).type,"Diode");
        strcpy((*dvmdata).unit, "");
        
        switch (byte5)
        {
           case 0x30: (*dvmdata).divisor = 1;
			strcpy((*dvmdata).prefix, "");
                    break;
        }
      break;
      }
 

   // Hz
   case 0x3C:
      {
        strcpy((*dvmdata).type,"Hz");
        strcpy((*dvmdata).unit, "Hz");
        
        switch (byte5)
        {
            case 0x30: (*dvmdata).divisor = 1000;
			strcpy((*dvmdata).prefix, "");
                    break;

            case 0x31: (*dvmdata).divisor = 100;
			strcpy((*dvmdata).prefix, "");
                    break;

            case 0x32: (*dvmdata).divisor = 10000;
			strcpy((*dvmdata).prefix, "k");
                    break;

            case 0x33: (*dvmdata).divisor = 1000;
			strcpy((*dvmdata).prefix, "k");
                    break;
            
            case 0x34: (*dvmdata).divisor = 100;
			strcpy((*dvmdata).prefix, "k");
                    break;

            case 0x35: (*dvmdata).divisor = 10000;
			strcpy((*dvmdata).prefix, "M");
                    break;

            case 0x36: (*dvmdata).divisor = 1000;
			strcpy((*dvmdata).prefix, "M");
                    break;

            case 0x37: (*dvmdata).divisor = 100;
			strcpy((*dvmdata).prefix, "M");
                    break;
        }
      break;
      }
    // Temperatur Grad F
   case 0x3D:
      {
        strcpy((*dvmdata).type,"Temperature");
        strcpy((*dvmdata).unit, "°F");
        
        switch (byte5)
        {
            case 0x30: (*dvmdata).divisor = 10;
			strcpy((*dvmdata).prefix, "");
                    break;
        }
      break;
      }

    // Unspecified
   case 0x3E:
      {
        strcpy((*dvmdata).type,"Unspecified");
        strcpy((*dvmdata).unit, "");
        
        switch (byte5)
        {
            default: (*dvmdata).divisor = 1;
			strcpy((*dvmdata).prefix, "");
                    break;
        }
      break;
      }

    // 
   case 0x3F:
      {
        strcpy((*dvmdata).type,"%(4-20mA)");
        strcpy((*dvmdata).unit, "%");
        
        switch (byte5)
        {
            case 0x30: (*dvmdata).divisor = 1;
			strcpy((*dvmdata).prefix, "");
                    break;
        }
      break;
      }

   } // Ende switch (byte6)

   //sprintf(s,"%s%s%s",sign,prefix, unit);
}

int parity(unsigned char byte)
{
  int count =0;
  int i;
  for (i=0; i<8; i++)
  {
    count += byte % 2;
    byte = byte >> 1;
  }
  
  count = count % 2;
  return count;
}

void del_parity(unsigned char *byte)
{
  unsigned char andbyte = 0x7F;
  *byte = *byte & andbyte;
}


int set_dvm_data(char *bytes_eleven,struct dvm_data *dvmdata)
{
  int n = 0;

  if ((bytes_eleven!=0) && (dvmdata!=0))
  {
        int temppar = 0;
	// check and del parity bit
	for (n=0; n<11; n++)
	{
          if (parity(bytes_eleven[n])==1)
            {
              temppar+=1;
            }
	  del_parity(&(bytes_eleven[n]));
	}
        if (temppar==8)
         {
           (*dvmdata).parity=1;
         }
         else
         {
           (*dvmdata).parity=0;
         }

         // anhand von byte 5, 6 und 8 Einheit, Range und Vorzeichen herausfinden
	 dvm_unit(bytes_eleven[5], bytes_eleven[6], bytes_eleven[8], dvmdata);
         setSTATE_AUTO(bytes_eleven[8], dvmdata);
         setSTATE_ACDC(bytes_eleven[7], dvmdata);

         (*dvmdata).overload = isOverload(bytes_eleven);

	if ((*dvmdata).overload==0)
                {
               	(*dvmdata).digits=10000.0*digit(bytes_eleven[0])+1000.0*digit(bytes_eleven[1])+100.0*digit(bytes_eleven[2])+10.0*digit(bytes_eleven[3])+1*digit(bytes_eleven[4]);
        	}
        else
          {
           (*dvmdata).digits=0.0;
          }

    return 1;
  }

  return 0;
}