Ss_hc595.cpp

Go to the documentation of this file.

#include <Ss_hc595.h>

/** \brief costructor
 * \param latch ST (pin 12 of 74HC595) - Latch - Storage register clock
 * \param clock SH (pin 11 of 74HC595) - Shift register clock
 * \param data  DS (pin 14 of 74HC595) - Serial Data input
 */


hc595::hc595(uint8_t latch,uint8_t clock,uint8_t data,uint8_t  num)
{
  latchPin=latch;
  clockPin=clock;
  dataPin=data;
  Buffer=(uint8_t*)malloc(num);  // num is number of 74HC595 connected
  for(uint8_t i=0;i<num;i++) Buffer[i]=0;
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  num_595=num;

  b_Latch = digitalPinToBitMask(latchPin);;
  //b_Clock = digitalPinToBitMask(clockPin);;
  //b_Data = digitalPinToBitMask(dataPin);;


  p_Latch=(uint8_t *)portOutputRegister(digitalPinToPort(latchPin));
  //p_Clock=(uint8_t *)portOutputRegister(digitalPinToPort(clockPin));
  //p_Data=(uint8_t *)portOutputRegister(digitalPinToPort(dataPin));

}
/*
hc595::~hc595()
{
 free(Buffer);
 Buffer=0;
}*/

/** \brief internal function, don't use direcly
 */

void hc595::PulseE(uint8_t num)
{
  bitWrite(Buffer[num],3,LOW); // set enable pin to low
  Send595();
  delayMicroseconds(1);//delayMicroseconds(1);   // >450ns
  //__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t"); // fanne 8
  bitWrite(Buffer[num],3,HIGH); // set enable pin to  high
  Send595();
  delayMicroseconds(1);//delayMicroseconds(1);    //  >450ns
  //__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t");
  bitWrite(Buffer[num],3,LOW); // set enable pin to low
  Send595();
  delayMicroseconds(38);   //  > 37us
}

/** \brief It sends the internal buffer to the shift register chain. This produce a update of all outputs of all shift registers. 
 */
void hc595::Send595(void)
{
  #ifdef HC595_DP

 // latch,clock,data - 2, 4, 7

  PORTD &= ~ B0000100; // B4 LOW - Latch on pin 12
  for( uint8_t i=num_595;i;i--)
  {
   //FastshiftOut(dataPin, clockPin, Buffer[i-1]);//DirectshiftOut(Buffer[i-1]);//MSBFIRST


  register uint8_t k;
  register uint8_t tmp=128; //1<<7
  uint8_t send;
    for (k = 8; k ; k--)
  {
    send=((uint8_t)Buffer[i-1] &tmp);s
    if(send) PORTD |=  B10000000; // 7H
    else PORTD &= ~ B10000000;    //7L
    PORTD |=  B00010000;//f_FastdigitalWrite(clockPin, HIGH);//fastandfast(clockPin, HIGH);// D4H
    PORTD &= ~ B00010000;//f_FastdigitalWrite(clockPin, LOW);//fastandfast(clockPin, LOW);// D4L
        tmp=tmp>>1;
    }




  }



  PORTD |=  B0000100; // D2 HIGH - Latch on pin 4
  #else
   *p_Latch &= ~(uint8_t)b_Latch;//DirectdigitalWrite(b_Latch,p_Latch, LOW); //FastdigitalWrite(latchPin, LOW);//*p_Latch &= ~b_Latch; //
   for(register uint8_t i=num_595;i;i--) FastshiftOut(dataPin, clockPin, Buffer[i-1]);//DirectshiftOut(Buffer[i-1]);//MSBFIRST
   *p_Latch |=(uint8_t) b_Latch;//DirectdigitalWrite(b_Latch,p_Latch, HIGH);//FastdigitalWrite(latchPin, HIGH);//*p_Latch |= b_Latch;///
 #endif
}
/** \brief It works as the sum of Set595Pin and the Send595, in the sense that sets the 8-bit and sends them directly to the shift register.
 *If you have only one shift register to edit you should use this function. If you need to change more than one at the same time you should use two or more Set595 and eventually Send595 at the end. 
 * \param val is the 8 bit buffer to fill relative 74HC595
 * \param display is the number of shift register on the chain (0 is the first!).
 */
void hc595::Send595Pin(uint8_t val,uint8_t display)
{
  Set595Pin(val,display);
  Send595();
}

/** \brief Using this function you can set every bit of the buffer of a single 74HC595 internal buffer using single bits.
 * \param D7-0 are single true or false values of single bits 
 * \param num is the number of shift register in the chain.
 */
void hc595::Set595Pin(bool D7,bool D6,bool D5,bool D4,bool D3,bool D2,bool D1,bool D0,uint8_t num)
{
 Buffer[num]=(D7<<7)+(D6<<6)+(D5<<5)+(D4<<4)+(D3<<3)+(D2<<2)+(D1<<1)+D0;
}
/** \brief set internal buffer of single 74hc595 (without update the real chip status but only internal buffer
 * \param val is the 8 bit buffer to fill relative 74HC595
 * \param display is the number of shift register on the chain (0 is the first!).
 */
void hc595::Set595Pin(uint8_t val,uint8_t num)
{
 Buffer[num]=val;
}
/** \brief Sets the free pins (2 and 0) of 74HC595 connected to a display. , 
 * \param pin is the pin (0 or 2)
 * \params status is the state (HIGH o LOW)
 * \param sr and sr is the shift register number (from 0). 
 */
void hc595::Lcd_SetFreePin(uint8_t pin, bool status,uint8_t sr)
{
  bitWrite(Buffer[sr],pin,status);
  Send595();
}
/** \brief Reset of the display 
 * \param options You can combite (with |) more of this: 
 * <br>LCD595_BASIC_DISPLAY_INIT: standard reset
 * <br>LCD595_USEFONT_5X10: use the 5x10 font instead the 5x8 
 * <br>LCD595_MORELINES: use displays with more than one line. 
 * <br>If you leave a null value, the standard option is: LCD595_BASIC_DISPLAY_INIT | LCD595_USEFONT_5X10 | LCD595_MORELINES 
 * \params num is the number of shift register in the chain
 */
void hc595::DisplayReset(uint8_t options,uint8_t num)
{
  if(!options) options=LCD595_BASIC_DISPLAY_INIT | LCD595_USEFONT_5X10 | LCD595_MORELINES;
  //procedura di reset
  delayMicroseconds(4100); // attesa iniziale....40ms ( ho usato tempi abbondanti

  SetLcdPin(0,0,1,1,num); // invio 0011
  PulseE(num);
  delayMicroseconds(4200); // 4.1ms

  SetLcdPin(0,0,1,1,num); // reinvio 0011
  PulseE(num);
  delayMicroseconds(110); // 100us

  SetLcdPin(0,0,1,1,num); // reinvio 0011
  PulseE(num);

  SetLcdPin(0,0,1,0,num); // ...settiamo i 4 bit...
  PulseE(num);


  SendLcdCommand(options,num);  // Inizializzazione con font e righe : 42    0 0 1 DL N F 0 0 (DL: 0 (4bit), N=1 (due righe)  F:5x8 (0) vs 15x10 (1))
  SendLcdCommand(LCD595_DISPLAY_ON,num);  // accendo il display
  SendLcdCommand(LCD595_DISPLAY_CLEAR,num);  // clear

}
/** \brief Write a string on the specificated display starting from actual position
 * \param buff is the buffer to write (null terminated!)
 * \params display is the shift register number in the chain. 
 */
void hc595::DisplayWrite(const char *buff,uint8_t display)
{
  int ln=strlen(buff);
  for(int i=0;i<ln;i++) {DisplayChar(buff[i],display);}

}
/** \brief Write a single char on the specificated display starting from actual position
 * \param buff is the char to write 
 * \params display is the shift register number in the chain. 
 */
void hc595::DisplayChar(uint8_t buff,uint8_t display)
{
  //scrivo una lettera OPPURE invio dati generici per altri scopi
  SetLcdRS(HIGH,display); // porto RS ad HIGH per indicare l'invio di DATI
  SetHLcd(buff,display);
  PulseE(display);
  SetLLcd(buff,display);
  PulseE(display);
  delayMicroseconds(37); // 37us
}
/// @cond nodoxy

void hc595::SetLcdPin(bool D7,bool D6,bool D5,bool D4,uint8_t num)
{
 bitWrite(Buffer[num],7,D7);
 bitWrite(Buffer[num],6,D6);
 bitWrite(Buffer[num],5,D5);
 bitWrite(Buffer[num],4,D4);
}

/// @endcond

/** \brief move virtual cursor to x,y position
 * \param x is the column
 * \params y is the row
 * \params type for now it's 1 or 2, depend of the specific display (different internal addressing). If you note x,y don't correspond as you want, change this parameter.
 * \display 
 */
void hc595::SetCursor(uint8_t X, uint8_t Y,uint8_t type,uint8_t display)
{
  int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };     //type 1
  if(type==2) {row_offsets[2]=0x10; row_offsets[3]=0x50;}

  if(Y>3) Y=Y%4;
  uint8_t val;
  val=(0x80 | (X + row_offsets[Y]));
  SendLcdCommand(val,display);
}

/// @cond nodoxy
void hc595::SetDDRAM_Address(uint8_t address,uint8_t display)
{
  uint8_t val=(0x80 | address);
  SendLcdCommand(val,display);
}
/// @endcond


/** \brief Used to redefine some custom characters. The char is the number of the character to redefine (0-7). Array is a 8bytes array with the bitmap of new character. sr is the number of the shift register. 

 * \params address is the char you want to change (0-7)
 * \params map is the buffer
 *  \param display is the number of register in the chain
 * 
 * \code
 *  byte MyChar[8] = {0,10,21,10,0,17,14,3}; 
 *  My595.CreateChar(0,MyChar,3); 
 *  My595.DisplayChar(0,3); 
 *
 * \endcode
 */
void hc595::CreateChar(uint8_t address,uint8_t map[],uint8_t display)
{
  address &= 0x7; // we have only 8 locations 0-7
  SendLcdCommand(0x40 | (address << 3),display);
  for (int i=0; i<8; i++) DisplayChar(map[i],display);

}

/** \brief This function is useful to send directly some commands to the display. 
 *\params val This is the option parameter which is a char in which every bit will be sent to the display. 
  There are some pre-set:
  <br>LCD595_DISPLAY_ON_CB: Switch on the display with blinking cursor on. 
  <br>LCD595_DISPLAY_ON_C: Switch on the display with NOT blinking cursor. 
  <br>LCD595_DISPLAY_ON_B: Switch on the display with last char blinking. 
  <br>LCD595_DISPLAY_ON: Switch on display without cursor. 
  <br>LCD595_DISPLAY_OFF: Switch off the display 
  <br>LCD595_DISPLAY_CLEAR: Cleans the display.

 * \params display is the shift register number on the chain
 * 
 * \code
 *  My595.SendLcdCommand(LCD595_DISPLAY_ON_C,3); 
 *
 * \endcode
 */







 void hc595::SendLcdCommand(uint8_t val,uint8_t display)
 {
   SetLcdRS(LOW,display);
   SetHLcd(val,display);
   PulseE(display);
   SetLLcd(val,display);
   PulseE(display);
   delayMicroseconds(37); // 37us
   if(val==LCD595_DISPLAY_CLEAR) delayMicroseconds(15300);//delay(2); //1.52ms
}
/// @cond nodoxy

 void hc595::SetLcdRS(bool Val,uint8_t display)
 {
  bitWrite(Buffer[display],1,Val); // porto RS ad HIGH per indicare l'invio di DATI o LOW per i comandi

 }

 void hc595::SetHLcd(uint8_t val,uint8_t display)
 {
  SetLcdPin(bitRead(val,7),bitRead(val,6),bitRead(val,5),bitRead(val,4),display); // primi 4
 }

 void hc595::SetLLcd(uint8_t val,uint8_t display)
 {
  SetLcdPin(bitRead(val,3),bitRead(val,2),bitRead(val,1),bitRead(val,0),display); // ultimi 4
 }

/// @endcond

/*
inline void hc595::DirectdigitalWrite(uint8_t bit, uint8_t * out,uint8_t val)
{
  val?*out |= (uint8_t)bit:*out &= ~(uint8_t)bit;
  //if (val != LOW) *out |= bit;
  //else *out &= ~bit;

}*/
/*
void hc595::DirectshiftOut(const uint8_t val)
{
    for (uint8_t i = 0; i < 8; i++)
  {
    ( (val & (1 << (7 - i))) != LOW)?*p_Data |= (uint8_t)b_Data:*p_Data &= ~(uint8_t)b_Data;
    //hc595_DirectdigitalWrite(b_Data,p_Data, !!(val & (1 << (7 - i))));
    //( !!(val & (1 << (7 - i))) != LOW)?*p_Data |= b_Data:*p_Data &= ~b_Data;
        //f_FastdigitalWrite(dataPin, !!(val & (1 << (7 - i))));

        *p_Clock |= (uint8_t)b_Clock; //DirectdigitalWrite(b_Clock,p_Clock, HIGH); //f_FastdigitalWrite(clockPin, HIGH);
        *p_Clock &= ~(uint8_t)b_Clock;//DirectdigitalWrite(b_Clock,p_Clock, LOW);//f_FastdigitalWrite(clockPin, LOW);
    }
}
*/