extern u8 Keypad_u8Read(void)
{
u8 Local_u8LoopRowCounter=0;
u8 Local_u8LoopCounter=0;
u8 Local_u8LoopColCounter=0;
u8 Local_u8SwitchState=0;
static u8 Local_u8ReturnNum=1;
u8 x=0;
for (Local_u8LoopRowCounter=0;Local_u8LoopRowCounter<4;Local_u8LoopRowCounter++)
{
for (Local_u8LoopCounter=0;Local_u8LoopCounter<4;Local_u8LoopCounter++)
{ DIO_u8WritePinVal(Rows_u8Arr[Local_u8LoopCounter],DIO_u8LOW);}
DIO_u8WritePinVal(Rows_u8Arr[Local_u8LoopRowCounter],DIO_u8HIGH);
for (Local_u8LoopColCounter=0;Local_u8LoopColCounter<4;Local_u8LoopColCounter++)
{
x=Check_u8SwitchState(Cols_u8Arr[Local_u8LoopColCounter]);
if(x==u8PRESSED)
{
Local_u8ReturnNum=Local_u8LoopRowCounter*4+Local_u8LoopColCounter+1;
}
}
}
return Local_u8ReturnNum;
}
void LCD_EnableLcd(void)
{
DIO_u8WritePinVal(LCD_u8Enable,DIO_u8HIGH );
Delay_ms_Max1s(1);
DIO_u8WritePinVal(LCD_u8Enable,DIO_u8LOW );
Delay_ms_Max1s(1);
}
void main (void)
{
u8 x ;
DIO_voidInit();
u8 cola_H[]={1,1,1,1,1,1,1,1};
u8 rowa_H[]={1,1,1,1,1,1,1,1};
DIO_u8WritePinDir(17,1);
DIO_u8WritePinDir(16,0);
while(1)
{
// Write_M() ;
// Write_A() ;
// Write_M() ;
// Write_D() ;
// Write_O() ;
// Write_H() ;
TSW_u8ReadState(0,&x);
if(x==1)
{
DIO_u8WritePinVal(17,1);
}
else
{
DIO_u8WritePinVal(17,0);
}
}
}
int main(void)
{
DIO_voidInit();
SSD_voidInit();
p[0] = letterA;
p[1] = letterN;
p[2] = letterW;
p[3] = letterA;
p[4] = letterR;
DIO_u8WritePinVal(otpt_pin,0); // output enable
DIO_u8WritePinVal(sh_clk,0); // output enable
while(1)
{
Segments();
//for(u8 ii=0;ii<5;ii++)
// {
// DIO_u8WritePinVal(16,1);
//for(u8 i=0;i<50;i++)
//{
// (*p[0])();
//}
// DIO_u8WritePinVal(16,0);
//}
}
return 0;
}
int main(void) {
u8 Local_u8SwitchValue; // to store the Switch Value
u8 Local_u8SwitchFlag = FALSE; // to run the switch in the single mode
u16 Local_u16ADCValue; // to store the ADC Value
u16 Local_u16PrevADCValue = 2000; // to store the Previous ADC Value
f32 Local_f32VoltageValue;
u8 Local_u8Buffer[5]; // to store the Volt value as characters
DIO_voidInit();
ADC_voidInit();
ADC_voidEnable();
LCD_voidInit();
LCD_u8Write_String("Voltage:");
//LCD_u8Write_Command(0x80); //go to First line and --0 is for 0th position
while (1) {
TSW_u8CheckSwitch(TSW_u8NUM1, &Local_u8SwitchValue);
if (Local_u8SwitchValue == TSW_u8PRESSED) {
if (!Local_u8SwitchFlag) {
Local_u8SwitchFlag = TRUE;
DIO_u8WritePinVal(RELAYCONTROL, DIO_u8HIGH);
}
} else { //Local_u8SwitchValue == TSW_u8RELEASED
if (Local_u8SwitchFlag) {
Local_u8SwitchFlag = FALSE;
DIO_u8WritePinVal(RELAYCONTROL, DIO_u8LOW);
}
}
//ADC_u8ReadChannel(ADC_u8CH7, &Local_u16ADCValue);
ADC_u8ReadChannelFiltered(ADC_u8CH7, &Local_u16ADCValue);
if (Local_u16ADCValue == Local_u16PrevADCValue) {
} else { //Local_u16ADCValue != Local_u16PrevADCValue
Local_u16PrevADCValue = Local_u16ADCValue;
CalculateVlotage(Local_u8SwitchFlag, Local_u16ADCValue, &Local_f32VoltageValue);
ftoa(Local_u8Buffer, Local_f32VoltageValue, 2);
//Local_f32VoltageValue = Local_u16ADCValue * ADC_STEP;
// Local_u8IntVoltageValue = Local_f32VoltageValue;
// itoa(Local_u8IntVoltageValue, Local_u8PotienoValue, 10);
// LCD_u8Write_Command(0xC0); //go to Second line and --0 is for 0th position
//dtostrf(value, width, precision, char array)
LCD_u8Write_Command(0xC0); //go to Second line and --0 is for 0th position
LCD_u8Write_String(Local_u8Buffer);
LCD_u8Write_String(" ");
// LCD_u8Write_String(".");
// Local_f32VoltageValue = Local_f32VoltageValue - Local_u8IntVoltageValue;
// Local_u8IntVoltageValue = 100 * Local_f32VoltageValue;
// itoa(Local_u8IntVoltageValue, Local_u8PotienoValue, 10);
// LCD_u8Write_String(Local_u8PotienoValue);
}
}
return 0;
}
void Write_D(void)
{
//////////////D//////////////////////
u8 cola_D[]={1,0,0,0,0,0,0,0};
u8 rowa_D[]={1,1,1,1,1,1,1,1};
u8 colb_D[]={0,1,0,0,0,0,0,0};
u8 rowb_D[]={1,0,0,0,0,0,0,1};
u8 colc_D[]={0,0,1,0,0,0,0,0};
u8 rowc_D[]={1,0,0,0,0,0,0,1};
u8 cold_D[]={0,0,0,1,0,0,0,0};
u8 rowd_D[]={0,1,0,0,0,0,1,0};
u8 cole_D[]={0,0,0,0,1,0,0,0};
u8 rowe_D[]={0,0,1,1,1,1,0,0};
u8 x =30 ;
while(x)
{
cols(cola_D);
rows(rowa_D);
DIO_u8WritePinVal(latch,1);
DELAY(0.001);
DIO_u8WritePinVal(latch,0);
cols(colb_D);
rows(rowb_D);
DIO_u8WritePinVal(latch,1);
DELAY(0.001);
DIO_u8WritePinVal(latch,0);
cols(colc_D);
rows(rowc_D);
DIO_u8WritePinVal(latch,1);
DELAY(0.001);
DIO_u8WritePinVal(latch,0);
cols(cold_D);
rows(rowd_D);
DIO_u8WritePinVal(latch,1);
DELAY(0.001);
DIO_u8WritePinVal(latch,0);
cols(cole_D);
rows(rowe_D);
DIO_u8WritePinVal(latch,1);
DELAY(0.001);
DIO_u8WritePinVal(latch,0);
x-- ;
}
}
void letterA(void)
{
/***letter A****/
for(u8 i=0;i<6;i++)
{
// shift(rows[i],cols[i]);
u8 R=rows[i];
u8 C=cols[0][i];
DIO_u8WritePinVal(otpt_pin,0); //output enable
for(s8 i=0;i<8;i++)
{
DIO_u8WritePinVal(DS_pin,GETBIT(R,i)); // rows
DIO_u8WritePinVal(sh_clk,0); ///clk
DIO_u8WritePinVal(sh_clk,1); //clk
}
for(s8 i=0;i<8;i++)
{
DIO_u8WritePinVal(DS_pin,GETBIT(C,i)); //columns
DIO_u8WritePinVal(sh_clk,0); //clk
DIO_u8WritePinVal(sh_clk,1); //clk
}
DIO_u8WritePinVal(otpt_pin,1); // output enable
}
/*DIO_u8WritePortVal(2,0b00000000); //switch all off
DIO_u8WritePortVal(3,0b11111011); //row //low //
DIO_u8WritePortVal(2,0b00011000); //cols //high //
Delay(1);
DIO_u8WritePortVal(2,0b00000000); //switch all off
DIO_u8WritePortVal(3,0b11110111); //row //low //
DIO_u8WritePortVal(2,0b00100100); //cols //high //
Delay(1);
DIO_u8WritePortVal(2,0b00000000); //switch all off
DIO_u8WritePortVal(3,0b11101111); //row //low //
DIO_u8WritePortVal(2,0b01000010); //cols //high //
Delay(1);
DIO_u8WritePortVal(2,0b00000000); //switch all off
DIO_u8WritePortVal(3,0b11011111); //row //low //
DIO_u8WritePortVal(2,0b01111110); //cols //high //
Delay(1);
DIO_u8WritePortVal(2,0b00000000); //switch all off
DIO_u8WritePortVal(3,0b10111111); //row //low //
DIO_u8WritePortVal(2,0b01000010); //cols //high //
Delay(1);
DIO_u8WritePortVal(2,0b00000000); //switch all off
DIO_u8WritePortVal(3,0b01111111); //row //low //
DIO_u8WritePortVal(2,0b01000010); //cols //high //
Delay(1);*/
}
void main (void)
{
u8 x ;
DIO_voidInit();
while(1)
{
DIO_u8WritePinVal(24,1);
DIO_u8ReadPinVal(23,&x);
if(x==1)
DIO_u8WritePinVal(28,1);
else if(x==0)
DIO_u8WritePinVal(28,0);
}
}
extern u8 SSD_u8TurnOff(u8 Copy_u8DispIdx) {
u8 Local_u8Display_Type;
u8 Local_u8Pin_Idx;
u8 Local_u8Control_Signal;
u8 Local_u8ErrorFlag;
/*Comment!:Check range*/
if (SSD_u8DISPCOUNT != 0 && Copy_u8DispIdx < SSD_u8DISPCOUNT) {
/*Comment!: Get display type from display array*/
Local_u8Display_Type = SSD_u8Display_Type_Array[Copy_u8DispIdx];
/*Comment!: Clear control signal of display at Control_Signals_Array */
SSD_u8Control_Signals_Array[Copy_u8DispIdx] =
SSD_u8Control_Signals_Map[Local_u8Display_Type][SSD_u8OFFSTATE];
/*Comment!: Deactivate display */
Local_u8Pin_Idx = SSD_u8DIO_MAP[Copy_u8DispIdx][SSD_u8SEGCOMMON];
Local_u8Control_Signal = SSD_u8Control_Signals_Array[Copy_u8DispIdx];
DIO_u8WritePinVal(Local_u8Pin_Idx, Local_u8Control_Signal);
Local_u8ErrorFlag = ok;
} else {
Local_u8ErrorFlag = error;
}
return Local_u8ErrorFlag;
}
void cols(u8 *PIN_NUM)
{
u8 i ;
for(i=0 ;i<8;i++ )
{
if(PIN_NUM[i]==1)
DIO_u8WritePinVal(ds,1);
else
DIO_u8WritePinVal(ds,0);
DIO_u8WritePinVal(clk,1);
DELAY(0.01);
DIO_u8WritePinVal(clk,0);
}
}
int main(void) {
__asm__("SEI");
MCUCR |= (1<<0);//make it on change
GICR |= (1<<6); // PIE for INT0
DIO_u8WritePinDir(26,DIO_u8INPUT);
DIO_u8WritePinDir(8,DIO_u8OUTPUT);
DIO_u8WritePinDir(9,DIO_u8OUTPUT);
while (1) {
DIO_u8WritePinVal(8,LEDFlag);
DIO_u8WritePinVal(9,DIO_u8HIGH);
voidDELAY_MS(1000);
DIO_u8WritePinVal(9,DIO_u8LOW);
voidDELAY_MS(1000);
}
return 0;
}
void LCD_WaitLcd(void)
{
u8 Local_u8ValBusyFlag;
#if (LCD_u8LcdMode == LCD_u8Bit4)
DIO_u8WritePinDir(LCD_u8D0,DIO_u8INPUT);//lcdd7=i/p .
DIO_u8WritePinDir(LCD_u8D1,DIO_u8INPUT);//lazm el 4 yb2o i/p 3shan ama b2lb enable mn high l low bib3t lcd btb3t high
DIO_u8WritePinDir(LCD_u8D2,DIO_u8INPUT);//lazm el 4 yb2o i/p 3shan ama b2lb enable mn high l low bib3t lcd btb3t high
DIO_u8WritePinDir(LCD_u8D3,DIO_u8INPUT);//lazm el 4 yb2o i/p 3shan ama b2lb enable mn high l low bib3t lcd btb3t high
DIO_u8WritePinVal(LCD_u8ReadWrite,DIO_u8HIGH);//rw=1.
#elif (LCD_u8LcdMode == LCD_u8Bit8)
DIO_u8WritePinDir(LCD_u8D0,DIO_u8INPUT);
DIO_u8WritePinDir(LCD_u8D1,DIO_u8INPUT);
DIO_u8WritePinDir(LCD_u8D2,DIO_u8INPUT);
DIO_u8WritePinDir(LCD_u8D3,DIO_u8INPUT);
DIO_u8WritePinDir(LCD_u8D4,DIO_u8INPUT);
DIO_u8WritePinDir(LCD_u8D5,DIO_u8INPUT);
DIO_u8WritePinDir(LCD_u8D6,DIO_u8INPUT);
DIO_u8WritePinDir(LCD_u8D7,DIO_u8INPUT);
DIO_u8WritePinVal(LCD_u8ReadWrite,DIO_u8HIGH);//rw=1.
#endif
DIO_u8WritePinVal(LCD_u8Reset,DIO_u8LOW);//rs=0.
do
{
Local_u8ValBusyFlag=0;
DIO_u8WritePinVal(LCD_u8Enable,DIO_u8HIGH);//Enable=1.
Delay_ms_Max1s(1);
#if (LCD_u8LcdMode == LCD_u8Bit4)
DIO_u8ReadPinVal(LCD_u8D3,&Local_u8ValBusyFlag );
#elif (LCD_u8LcdMode == LCD_u8Bit8)
DIO_u8ReadPinVal(LCD_u8D7,&Local_u8ValBusyFlag );
#endif
Delay_ms_Max1s(1);
DIO_u8WritePinVal(LCD_u8Enable,DIO_u8LOW);//e=0.
Delay_ms_Max1s(1);
DIO_u8WritePinVal(LCD_u8Enable,DIO_u8HIGH);//e=1
Delay_ms_Max1s(1);
}while(Local_u8ValBusyFlag == LCD_u8Busy);
DIO_u8WritePinVal(LCD_u8ReadWrite,DIO_u8LOW);//rw=0.
#if (LCD_u8LcdMode == LCD_u8Bit4)
DIO_u8WritePinDir(LCD_u8D0,DIO_u8OUTPUT);
DIO_u8WritePinDir(LCD_u8D1,DIO_u8OUTPUT);
DIO_u8WritePinDir(LCD_u8D2,DIO_u8OUTPUT);
DIO_u8WritePinDir(LCD_u8D3,DIO_u8OUTPUT);
Delay_ms_Max1s(1);
#elif (LCD_u8LcdMode == LCD_u8Bit8)
DIO_u8WritePinDir(LCD_u8D0,DIO_u8OUTPUT);
DIO_u8WritePinDir(LCD_u8D1,DIO_u8OUTPUT);
DIO_u8WritePinDir(LCD_u8D2,DIO_u8OUTPUT);
DIO_u8WritePinDir(LCD_u8D3,DIO_u8OUTPUT);
DIO_u8WritePinDir(LCD_u8D4,DIO_u8OUTPUT);
DIO_u8WritePinDir(LCD_u8D5,DIO_u8OUTPUT);
DIO_u8WritePinDir(LCD_u8D6,DIO_u8OUTPUT);
DIO_u8WritePinDir(LCD_u8D7,DIO_u8OUTPUT);
#endif
}
void Stepper_voidRotate(void)
{
static u8 local_u8loop = 1;
local_u8loop <<= 1;
if (local_u8loop == 16)
{
local_u8loop = 1;
}
DIO_u8WritePinVal(10, GET_BIT(local_u8loop, 0));
DIO_u8WritePinVal(11, GET_BIT(local_u8loop, 1));
DIO_u8WritePinVal(12, GET_BIT(local_u8loop, 2));
DIO_u8WritePinVal(13, GET_BIT(local_u8loop, 3));
}
void Write_H(void)
{
u8 cola_H[]={1,0,0,0,0,0,0,0};
u8 rowa_H[]={1,1,1,1,1,1,1,0};
u8 colb_H[]={1,1,1,1,1,1,1,1};
u8 rowb_H[]={0,0,0,1,0,0,0,0};
u8 colc_H[]={0,0,0,0,0,0,0,1};
u8 rowc_H[]={1,1,1,1,1,1,1,0};
u8 x = 50 ;
while(x)
{
cols(cola_H);
rows(rowa_H);
DIO_u8WritePinVal(latch,1);
DELAY(0.001);
DIO_u8WritePinVal(latch,0);
cols(colb_H);
rows(rowb_H);
DIO_u8WritePinVal(latch,1);
DELAY(0.001);
DIO_u8WritePinVal(latch,0);
cols(colc_H);
rows(rowc_H);
DIO_u8WritePinVal(latch,1);
DELAY(0.001);
DIO_u8WritePinVal(latch,0);
x--;
}
}
void main(void) {
u16 Local_u8ADCReading;
u16 Local_u8LCDresult[5];
u8 Local_u8SW;
u8 Local_u8ADCanalog;
DIO_voidInit();
TACTILE_voidInit();
ADC_voidConfig();
ADC_voidEnable();
LCD_voidInit();
while (1) {
ADC_voidReadSingleShot(&Local_u8ADCReading);
DIO_u8ReadPinVal(DIO_u8PIN31, &Local_u8SW);
Local_u8ADCanalog=((Local_u8ADCReading>>6)*(u16)5)/(u16)1024;
switch (Local_u8SW) {
case TACTILE_u8Pressed:
DIO_u8WritePinVal(DIO_u8PIN27, 1);
itoa(Local_u8ADCanalog+5, Local_u8LCDresult, 10);
LCD_voidWriteString(Local_u8LCDresult);
delay_ms(5);
break;
case TACTILE_u8Released:
DIO_u8WritePinVal(DIO_u8PIN27, 0);
itoa(Local_u8ADCanalog, Local_u8LCDresult, 10);
LCD_voidWriteString(Local_u8LCDresult);
delay_ms(5);
break;
}
LCD_voidClearSceen();
}
return;
}
extern u8 SSD_u8Display(u8 Copy_u8DispIdx, u8 Copy_u8DispVal) {
u8 Local_u8ErrorFlag;
u8 Local_u8DispType;
/*Comment!:Check range*/
if (SSD_u8DISPCOUNT != 0 && Copy_u8DispIdx < SSD_u8DISPCOUNT) {
/*Comment!: Copy values to values array */
SSD_u8Values_Array[Copy_u8DispIdx] = Copy_u8DispVal;
/*Comment!: Write number to 7 segments*/
Local_u8DispType = SSD_u8Display_Type_Array[Copy_u8DispIdx];
DIO_u8WritePinVal(SSD_u8DIO_MAP[Copy_u8DispIdx][SSD_u8SEGA],
SSD_u8Numbers_Array[Local_u8DispType][Copy_u8DispVal][SSD_u8SEGA]);
Local_u8DispType = SSD_u8Display_Type_Array[Copy_u8DispIdx];
DIO_u8WritePinVal(SSD_u8DIO_MAP[Copy_u8DispIdx][SSD_u8SEGB],
SSD_u8Numbers_Array[Local_u8DispType][Copy_u8DispVal][SSD_u8SEGB]);
Local_u8DispType = SSD_u8Display_Type_Array[Copy_u8DispIdx];
DIO_u8WritePinVal(SSD_u8DIO_MAP[Copy_u8DispIdx][SSD_u8SEGC],
SSD_u8Numbers_Array[Local_u8DispType][Copy_u8DispVal][SSD_u8SEGC]);
Local_u8DispType = SSD_u8Display_Type_Array[Copy_u8DispIdx];
DIO_u8WritePinVal(SSD_u8DIO_MAP[Copy_u8DispIdx][SSD_u8SEGD],
SSD_u8Numbers_Array[Local_u8DispType][Copy_u8DispVal][SSD_u8SEGD]);
Local_u8DispType = SSD_u8Display_Type_Array[Copy_u8DispIdx];
DIO_u8WritePinVal(SSD_u8DIO_MAP[Copy_u8DispIdx][SSD_u8SEGE],
SSD_u8Numbers_Array[Local_u8DispType][Copy_u8DispVal][SSD_u8SEGE]);
Local_u8DispType = SSD_u8Display_Type_Array[Copy_u8DispIdx];
DIO_u8WritePinVal(SSD_u8DIO_MAP[Copy_u8DispIdx][SSD_u8SEGF],
SSD_u8Numbers_Array[Local_u8DispType][Copy_u8DispVal][SSD_u8SEGF]);
Local_u8DispType = SSD_u8Display_Type_Array[Copy_u8DispIdx];
DIO_u8WritePinVal(SSD_u8DIO_MAP[Copy_u8DispIdx][SSD_u8SEGG],
SSD_u8Numbers_Array[Local_u8DispType][Copy_u8DispVal][SSD_u8SEGG]);
/*Comment!: Write to common pin at 7 segment*/
DIO_u8WritePinVal(SSD_u8DIO_MAP[Copy_u8DispIdx][7],
SSD_u8Control_Signals_Array[Copy_u8DispIdx]);
Local_u8ErrorFlag = ok;
} else {
Local_u8ErrorFlag = error;
}
return Local_u8ErrorFlag;
}
void shift(u8 R,u8 C)
{
DIO_u8WritePinVal(otpt_pin,0); //output enable
for(s8 i=0;i<8;i++)
{
DIO_u8WritePinVal(DS_pin,GETBIT(R,i)); // rows
DIO_u8WritePinVal(sh_clk,0); ///clk
DIO_u8WritePinVal(sh_clk,1); //clk
}
for(s8 i=0;i<8;i++)
{
DIO_u8WritePinVal(DS_pin,GETBIT(C,i)); //columns
DIO_u8WritePinVal(sh_clk,0); //clk
DIO_u8WritePinVal(sh_clk,1); //clk
}
DIO_u8WritePinVal(otpt_pin,1); // output enable
}
void step()
{
if (flg==0)
{
DIO_u8WritePinVal(st1,get_bit(m,0));
DIO_u8WritePinVal(st2,get_bit(m,1));
DIO_u8WritePinVal(st3,get_bit(m,2));
DIO_u8WritePinVal(st4,get_bit(m,3));
}
else
{
DIO_u8WritePinVal(st4,get_bit(m,0));
DIO_u8WritePinVal(st3,get_bit(m,1));
DIO_u8WritePinVal(st2,get_bit(m,2));
DIO_u8WritePinVal(st1,get_bit(m,3));
}
m<<=1 ;
if(m==16)
m=1 ;
}
extern void RTOS_YellowOffTask(void)
{
DIO_u8WritePinVal(RTOS_u8YellowLed,RTOS_u8LedOff);
}
void LCD_VoidCmd(u8 LCD_u8Command)
{
//LCD_u8Port=LCD_u8Command;
LCD_WaitLcd();
#if (LCD_u8LcdMode == LCD_u8Bit8)
DIO_u8WritePinVal(LCD_u8Reset,DIO_u8LOW );
DIO_u8WritePinVal(LCD_u8D0,(LCD_u8Command&Lcd_u8Bit0 ));
DIO_u8WritePinVal(LCD_u8D1,(LCD_u8Command&Lcd_u8Bit1 ));
DIO_u8WritePinVal(LCD_u8D2,(LCD_u8Command&Lcd_u8Bit2 ));
DIO_u8WritePinVal(LCD_u8D3,(LCD_u8Command&Lcd_u8Bit3 ));
DIO_u8WritePinVal(LCD_u8D4,(LCD_u8Command&Lcd_u8Bit4 ));
DIO_u8WritePinVal(LCD_u8D5,(LCD_u8Command&Lcd_u8Bit5 ));
DIO_u8WritePinVal(LCD_u8D6,(LCD_u8Command&Lcd_u8Bit6 ));
DIO_u8WritePinVal(LCD_u8D7,(LCD_u8Command&Lcd_u8Bit7 ));
LCD_EnableLcd();
//Delay_ms_Max1s(50);
#else
DIO_u8WritePinVal(LCD_u8Reset,DIO_u8LOW );
//LCD_MaskLcdPins();
DIO_u8WritePinVal(LCD_u8D0,(LCD_u8Command&Lcd_u8Bit4 ) );
DIO_u8WritePinVal(LCD_u8D1,(LCD_u8Command&Lcd_u8Bit5 ) );
DIO_u8WritePinVal(LCD_u8D2,(LCD_u8Command&Lcd_u8Bit6 ) );
DIO_u8WritePinVal(LCD_u8D3,(LCD_u8Command&Lcd_u8Bit7 ) );
LCD_EnableLcd();
//LCD_MaskLcdPins();
DIO_u8WritePinVal(LCD_u8D0,(LCD_u8Command&Lcd_u8Bit0 ) );
DIO_u8WritePinVal(LCD_u8D1,(LCD_u8Command&Lcd_u8Bit1 ) );
DIO_u8WritePinVal(LCD_u8D2,(LCD_u8Command&Lcd_u8Bit2 ) );
DIO_u8WritePinVal(LCD_u8D3,(LCD_u8Command&Lcd_u8Bit3 ) );
LCD_EnableLcd();
//Delay_ms_Max1s(50);
#endif
return;
}
extern void SSD_voidInit(void) {
/*Comment!:if there is at least one display initialize it*/
#if (SSD_u8DISPCOUNT>=1) && (SSD_u8DISPCOUNT<=6)
/*Comment!:set segment bins as output*/
DIO_u8WritePinDir(SSD_u8DISP1_SEGA, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP1_SEGB, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP1_SEGC, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP1_SEGD, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP1_SEGE, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP1_SEGF, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP1_SEGG, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP1_INITCOM, DIO_u8OUTPUT);
/*Comment!:set 7 segments initial value */
DIO_u8WritePinVal(SSD_u8DISP1_SEGA,
SSD_u8Numbers_Array[SSD_u8DISP1TYPE][SSD_u8DISP1_INITVAL][SSD_u8SEGA]);
DIO_u8WritePinVal(SSD_u8DISP1_SEGB,
SSD_u8Numbers_Array[SSD_u8DISP1TYPE][SSD_u8DISP1_INITVAL][SSD_u8SEGB]);
DIO_u8WritePinVal(SSD_u8DISP1_SEGC,
SSD_u8Numbers_Array[SSD_u8DISP1TYPE][SSD_u8DISP1_INITVAL][SSD_u8SEGC]);
DIO_u8WritePinVal(SSD_u8DISP1_SEGD,
SSD_u8Numbers_Array[SSD_u8DISP1TYPE][SSD_u8DISP1_INITVAL][SSD_u8SEGD]);
DIO_u8WritePinVal(SSD_u8DISP1_SEGE,
SSD_u8Numbers_Array[SSD_u8DISP1TYPE][SSD_u8DISP1_INITVAL][SSD_u8SEGE]);
DIO_u8WritePinVal(SSD_u8DISP1_SEGF,
SSD_u8Numbers_Array[SSD_u8DISP1TYPE][SSD_u8DISP1_INITVAL][SSD_u8SEGF]);
DIO_u8WritePinVal(SSD_u8DISP1_SEGG,
SSD_u8Numbers_Array[SSD_u8DISP1TYPE][SSD_u8DISP1_INITVAL][SSD_u8SEGG]);
DIO_u8WritePinVal(SSD_u8DISP1_INITCOM,
SSD_u8Control_Signals_Array[SSD_u8DISP1]);
#endif
/*Comment!:if there is at least two displays initialize them*/
#if (SSD_u8DISPCOUNT>=2) && (SSD_u8DISPCOUNT<=6)
/*Comment!:set segment bins as output*/
DIO_u8WritePinDir(SSD_u8DISP2_SEGA, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP2_SEGB, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP2_SEGC, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP2_SEGD, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP2_SEGE, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP2_SEGF, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP2_SEGG, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP2_INITCOM, DIO_u8OUTPUT);
/*Comment!:set 7 segments initial value */
DIO_u8WritePinVal(SSD_u8DISP2_SEGA,
SSD_u8Numbers_Array[SSD_u8DISP2TYPE][SSD_u8DISP2_INITVAL][SSD_u8SEGA]);
DIO_u8WritePinVal(SSD_u8DISP2_SEGB,
SSD_u8Numbers_Array[SSD_u8DISP2TYPE][SSD_u8DISP2_INITVAL][SSD_u8SEGB]);
DIO_u8WritePinVal(SSD_u8DISP2_SEGC,
SSD_u8Numbers_Array[SSD_u8DISP2TYPE][SSD_u8DISP2_INITVAL][SSD_u8SEGC]);
DIO_u8WritePinVal(SSD_u8DISP2_SEGD,
SSD_u8Numbers_Array[SSD_u8DISP2TYPE][SSD_u8DISP2_INITVAL][SSD_u8SEGD]);
DIO_u8WritePinVal(SSD_u8DISP2_SEGE,
SSD_u8Numbers_Array[SSD_u8DISP2TYPE][SSD_u8DISP2_INITVAL][SSD_u8SEGE]);
DIO_u8WritePinVal(SSD_u8DISP2_SEGF,
SSD_u8Numbers_Array[SSD_u8DISP2TYPE][SSD_u8DISP2_INITVAL][SSD_u8SEGF]);
DIO_u8WritePinVal(SSD_u8DISP2_SEGG,
SSD_u8Numbers_Array[SSD_u8DISP2TYPE][SSD_u8DISP2_INITVAL][SSD_u8SEGG]);
DIO_u8WritePinVal(SSD_u8DISP2_INITCOM,
SSD_u8Control_Signals_Array[SSD_u8DISP2]);
#endif
/*Comment!:if there is at least three displays initialize them*/
#if (SSD_u8DISPCOUNT>=3) && (SSD_u8DISPCOUNT<=6)
/*Comment!:set segment bins as output*/
DIO_u8WritePinDir(SSD_u8DISP3_SEGA, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP3_SEGB, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP3_SEGC, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP3_SEGD, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP3_SEGE, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP3_SEGF, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP3_SEGG, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP3_INITCOM, DIO_u8OUTPUT);
/*Comment!:set 7 segments initial value */
DIO_u8WritePinVal(SSD_u8DISP3_SEGA,
SSD_u8Numbers_Array[SSD_u8DISP3TYPE][SSD_u8DISP3_INITVAL][SSD_u8SEGA]);
DIO_u8WritePinVal(SSD_u8DISP3_SEGB,
SSD_u8Numbers_Array[SSD_u8DISP3TYPE][SSD_u8DISP3_INITVAL][SSD_u8SEGB]);
DIO_u8WritePinVal(SSD_u8DISP3_SEGC,
SSD_u8Numbers_Array[SSD_u8DISP3TYPE][SSD_u8DISP3_INITVAL][SSD_u8SEGC]);
DIO_u8WritePinVal(SSD_u8DISP3_SEGD,
SSD_u8Numbers_Array[SSD_u8DISP3TYPE][SSD_u8DISP3_INITVAL][SSD_u8SEGD]);
DIO_u8WritePinVal(SSD_u8DISP3_SEGE,
SSD_u8Numbers_Array[SSD_u8DISP3TYPE][SSD_u8DISP3_INITVAL][SSD_u8SEGE]);
DIO_u8WritePinVal(SSD_u8DISP3_SEGF,
SSD_u8Numbers_Array[SSD_u8DISP3TYPE][SSD_u8DISP3_INITVAL][SSD_u8SEGF]);
DIO_u8WritePinVal(SSD_u8DISP3_SEGG,
SSD_u8Numbers_Array[SSD_u8DISP3TYPE][SSD_u8DISP3_INITVAL][SSD_u8SEGG]);
DIO_u8WritePinVal(SSD_u8DISP3_INITCOM,
SSD_u8Control_Signals_Array[SSD_u8DISP3]);
#endif
/*Comment!:if there is at least one display initialize it*/
#if (SSD_u8DISPCOUNT>=4) && (SSD_u8DISPCOUNT<=6)
/*Comment!:set segment bins as output*/
DIO_u8WritePinDir(SSD_u8DISP4_SEGA, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP4_SEGB, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP4_SEGC, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP4_SEGD, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP4_SEGE, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP4_SEGF, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP4_SEGG, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP4_INITCOM, DIO_u8OUTPUT);
/*Comment!:set 7 segments initial value */
DIO_u8WritePinVal(SSD_u8DISP4_SEGA,
SSD_u8Numbers_Array[SSD_u8DISP4TYPE][SSD_u8DISP4_INITVAL][SSD_u8SEGA]);
DIO_u8WritePinVal(SSD_u8DISP4_SEGB,
SSD_u8Numbers_Array[SSD_u8DISP4TYPE][SSD_u8DISP4_INITVAL][SSD_u8SEGB]);
DIO_u8WritePinVal(SSD_u8DISP4_SEGC,
SSD_u8Numbers_Array[SSD_u8DISP4TYPE][SSD_u8DISP4_INITVAL][SSD_u8SEGC]);
DIO_u8WritePinVal(SSD_u8DISP4_SEGD,
SSD_u8Numbers_Array[SSD_u8DISP4TYPE][SSD_u8DISP4_INITVAL][SSD_u8SEGD]);
DIO_u8WritePinVal(SSD_u8DISP4_SEGE,
SSD_u8Numbers_Array[SSD_u8DISP4TYPE][SSD_u8DISP4_INITVAL][SSD_u8SEGE]);
DIO_u8WritePinVal(SSD_u8DISP4_SEGF,
SSD_u8Numbers_Array[SSD_u8DISP4TYPE][SSD_u8DISP4_INITVAL][SSD_u8SEGF]);
DIO_u8WritePinVal(SSD_u8DISP4_SEGG,
SSD_u8Numbers_Array[SSD_u8DISP4TYPE][SSD_u8DISP4_INITVAL][SSD_u8SEGG]);
DIO_u8WritePinVal(SSD_u8DISP4_INITCOM,
SSD_u8Control_Signals_Array[SSD_u8DISP4]);
#endif
/*Comment!:if there is at least one display initialize it*/
#if (SSD_u8DISPCOUNT>=5) && (SSD_u8DISPCOUNT<=6)
/*Comment!:set segment bins as output*/
DIO_u8WritePinDir(SSD_u8DISP5_SEGA, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP5_SEGB, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP5_SEGC, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP5_SEGD, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP5_SEGE, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP5_SEGF, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP5_SEGG, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP5_INITCOM, DIO_u8OUTPUT);
/*Comment!:set 7 segments initial value */
DIO_u8WritePinVal(SSD_u8DISP5_SEGA,
SSD_u8Numbers_Array[SSD_u8DISP5TYPE][SSD_u8DISP5_INITVAL][SSD_u8SEGA]);
DIO_u8WritePinVal(SSD_u8DISP5_SEGB,
SSD_u8Numbers_Array[SSD_u8DISP5TYPE][SSD_u8DISP5_INITVAL][SSD_u8SEGB]);
DIO_u8WritePinVal(SSD_u8DISP5_SEGC,
SSD_u8Numbers_Array[SSD_u8DISP5TYPE][SSD_u8DISP5_INITVAL][SSD_u8SEGC]);
DIO_u8WritePinVal(SSD_u8DISP5_SEGD,
SSD_u8Numbers_Array[SSD_u8DISP5TYPE][SSD_u8DISP5_INITVAL][SSD_u8SEGD]);
DIO_u8WritePinVal(SSD_u8DISP5_SEGE,
SSD_u8Numbers_Array[SSD_u8DISP5TYPE][SSD_u8DISP5_INITVAL][SSD_u8SEGE]);
DIO_u8WritePinVal(SSD_u8DISP5_SEGF,
SSD_u8Numbers_Array[SSD_u8DISP5TYPE][SSD_u8DISP5_INITVAL][SSD_u8SEGF]);
DIO_u8WritePinVal(SSD_u8DISP5_SEGG,
SSD_u8Numbers_Array[SSD_u8DISP5TYPE][SSD_u8DISP5_INITVAL][SSD_u8SEGG]);
DIO_u8WritePinVal(SSD_u8DISP5_INITCOM,
SSD_u8Control_Signals_Array[SSD_u8DISP5]);
#endif
/*Comment!:if there is at least one display initialize it*/
#if SSD_u8DISPCOUNT==6
/*Comment!:set segment bins as output*/
DIO_u8WritePinDir(SSD_u8DISP6_SEGA, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP6_SEGB, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP6_SEGC, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP6_SEGD, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP6_SEGE, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP6_SEGF, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP6_SEGG, DIO_u8OUTPUT);
DIO_u8WritePinDir(SSD_u8DISP6_INITCOM, DIO_u8OUTPUT);
/*Comment!:set 7 segments initial value */
DIO_u8WritePinVal(SSD_u8DISP6_SEGA,
SSD_u8Numbers_Array[SSD_u8DISP6TYPE][SSD_u8DISP6_INITVAL][SSD_u8SEGA]);
DIO_u8WritePinVal(SSD_u8DISP6_SEGB,
SSD_u8Numbers_Array[SSD_u8DISP6TYPE][SSD_u8DISP6_INITVAL][SSD_u8SEGB]);
DIO_u8WritePinVal(SSD_u8DISP6_SEGC,
SSD_u8Numbers_Array[SSD_u8DISP6TYPE][SSD_u8DISP6_INITVAL][SSD_u8SEGC]);
DIO_u8WritePinVal(SSD_u8DISP6_SEGD,
SSD_u8Numbers_Array[SSD_u8DISP6TYPE][SSD_u8DISP6_INITVAL][SSD_u8SEGD]);
DIO_u8WritePinVal(SSD_u8DISP6_SEGE,
SSD_u8Numbers_Array[SSD_u8DISP6TYPE][SSD_u8DISP6_INITVAL][SSD_u8SEGE]);
DIO_u8WritePinVal(SSD_u8DISP6_SEGF,
SSD_u8Numbers_Array[SSD_u8DISP6TYPE][SSD_u8DISP6_INITVAL][SSD_u8SEGF]);
DIO_u8WritePinVal(SSD_u8DISP6_SEGG,
SSD_u8Numbers_Array[SSD_u8DISP6TYPE][SSD_u8DISP6_INITVAL][SSD_u8SEGG]);
DIO_u8WritePinVal(SSD_u8DISP6_INITCOM,
SSD_u8Control_Signals_Array[SSD_u8DISP6]);
#endif
}
int main (void)
{
u8 KeyPadVal,Toggle_3=0,Toggle_2=0,Toggle_1=0,SwitchPin;
DIO_VoidInit();
ExtInt_Init();
Timer_VoidInit();
ExtInt_EnableGlobalInt();
//ExtInt_voidOverFlowInt0(Toggle);
ExtInt_voidSetExtInt0(Toggle);
while(1)
{
DIO_u8ReadPinVal(DIO_u8Pin24,&SwitchPin);
if(u8_DebounceSenceHigh(SwitchPin,Pressed) == Pressed)
{
DIO_u8WritePinVal(ExternaInterruptZeroPin,TurnOn);
}
else DIO_u8WritePinVal(ExternaInterruptZeroPin,TurnOff);
TotalTimeInMile=Timer_u16Count1mile();
KeyPadVal=KeyPad_StructRead();
if(KeyPadVal!=KeyPad_u8NoPressed)
{
KeyPadVal_2=KeyPadVal;
//PORTB=KeyPadVal_2 ;
}
else;
if(TotalTimeInMile>=250)
{
if(Led_1==FiredInterrupt)
{
if(ToggleLed1==FirstPressed)
{
DIO_u8WritePinVal(FirstLed,Toggle_1^=1);
}
else DIO_u8WritePinVal(FirstLed,TurnOff);
}
else;
if(Led_2==FiredInterrupt)
{
if(ToggleLed2==FirstPressed)
{
DIO_u8WritePinVal(SecondLed,Toggle_2^=1);
}
else DIO_u8WritePinVal(SecondLed,TurnOff);
}
else ;
if(Led_3==FiredInterrupt)
{
if(ToggleLed3==FirstPressed)
{
DIO_u8WritePinVal(ThirdLed,Toggle_3^=1);
}
else DIO_u8WritePinVal(ThirdLed,TurnOff);
}
else;
Timer_u16ResetCounter();
Timer_u16ResetTotalTime();
}
else;
}
return 0;
}
void StepperRunning(u8 KeyValue) {
static u8 Step = STEPPER_STEP_A; // 0,1,2,3
static u8 DelayCounter = 0;
DelayCounter++;
switch (Step) {
case STEPPER_STEP_A:
DIO_u8WritePinVal(STEPPER_MOTOR_PIN1, DIO_u8HIGH);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN2, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN3, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN4, DIO_u8LOW);
break;
case STEPPER_STEP_B:
DIO_u8WritePinVal(STEPPER_MOTOR_PIN2, DIO_u8HIGH);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN1, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN3, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN4, DIO_u8LOW);
break;
case STEPPER_STEP_C:
DIO_u8WritePinVal(STEPPER_MOTOR_PIN3, DIO_u8HIGH);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN1, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN2, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN4, DIO_u8LOW);
break;
case STEPPER_STEP_D:
DIO_u8WritePinVal(STEPPER_MOTOR_PIN4, DIO_u8HIGH);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN1, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN2, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN3, DIO_u8LOW);
break;
default:
break;
}
if (DelayCounter > (DELAY_FOR_STEPPER * KeyValue)) {
DelayCounter = 0;
if (Step == STEPPER_STEP_D)
Step = STEPPER_STEP_A;
else {
Step++;
}
}
}
extern void Buzzer_voidStop(void)
{
DIO_u8WritePinVal(DIO_u8PIN0,u8ZERO);
}
void StepperOFF(void) {
DIO_u8WritePinVal(STEPPER_MOTOR_PIN1, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN2, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN3, DIO_u8LOW);
DIO_u8WritePinVal(STEPPER_MOTOR_PIN4, DIO_u8LOW);
}
void LCD_VoidData(u8 LCD_u8Data)
{
LCD_WaitLcd();
#if (LCD_u8LcdMode == LCD_u8Bit8)
DIO_u8WritePinVal(LCD_u8Reset,DIO_u8HIGH );
DIO_u8WritePinVal(LCD_u8D0,(LCD_u8Data&Lcd_u8Bit0 ) );
DIO_u8WritePinVal(LCD_u8D1,(LCD_u8Data&Lcd_u8Bit1 ) );
DIO_u8WritePinVal(LCD_u8D2,(LCD_u8Data&Lcd_u8Bit2 ) );
DIO_u8WritePinVal(LCD_u8D3,(LCD_u8Data&Lcd_u8Bit3 ) );
DIO_u8WritePinVal(LCD_u8D4,(LCD_u8Data&Lcd_u8Bit4 ) );
DIO_u8WritePinVal(LCD_u8D5,(LCD_u8Data&Lcd_u8Bit5 ) );
DIO_u8WritePinVal(LCD_u8D6,(LCD_u8Data&Lcd_u8Bit6 ) );
DIO_u8WritePinVal(LCD_u8D7,(LCD_u8Data&Lcd_u8Bit7 ) );
//ctrl = (1<<rs)|(0<<rw)|(1<<en); // RW as LOW and RS, EN as HIGH
LCD_EnableLcd();
//Delay_ms_Max1s(50); // delay to get things executed
#else
DIO_u8WritePinVal(LCD_u8Reset,DIO_u8HIGH );
//LCD_MaskLcdPins();
DIO_u8WritePinVal(LCD_u8D0,(LCD_u8Data&Lcd_u8Bit4 ) );
DIO_u8WritePinVal(LCD_u8D1,(LCD_u8Data&Lcd_u8Bit5 ) );
DIO_u8WritePinVal(LCD_u8D2,(LCD_u8Data&Lcd_u8Bit6 ) );
DIO_u8WritePinVal(LCD_u8D3,(LCD_u8Data&Lcd_u8Bit7 ) );
LCD_EnableLcd();
//LCD_MaskLcdPins();
DIO_u8WritePinVal(LCD_u8D0,(LCD_u8Data&Lcd_u8Bit0 ) );
DIO_u8WritePinVal(LCD_u8D1,(LCD_u8Data&Lcd_u8Bit1 ) );
DIO_u8WritePinVal(LCD_u8D2,(LCD_u8Data&Lcd_u8Bit2 ) );
DIO_u8WritePinVal(LCD_u8D3,(LCD_u8Data&Lcd_u8Bit3 ) );
LCD_EnableLcd();
//Delay_ms_Max1s(50);
#endif
return ;
}
extern Keypad_u16Switches KEYPAD_Keypad_u16SwitchesRead(void)
{
u8 local_u8Switch_Current_State;
u8 local_u8SwitchIdx;
Keypad_u16Switches Keypad_u16State;
/*Comment!: Initialize Switches as unPressed */
Keypad_u16State.KEYPAD_u16Switches = KEYPAD_u16UNPRESSED;
/*Comment!: Loop over all rows*/
for (u8 Keypad_u8LoopCounter = 0; Keypad_u8LoopCounter < KEYPAD_u8NUM_ROWS; Keypad_u8LoopCounter++)
{
/*Comment!: make one output as pressed state and other outputs as released state */
for (u8 Keypad_u8RowsCounter = 0; Keypad_u8RowsCounter < KEYPAD_u8NUM_ROWS; Keypad_u8RowsCounter++)
{
if (Keypad_u8RowsCounter == Keypad_u8LoopCounter)
{
DIO_u8WritePinVal(Keypad_u8RowS_Array[Keypad_u8RowsCounter], KEYPAD_u8PRESSEDSTATE);
}
else
{
DIO_u8WritePinVal(Keypad_u8RowS_Array[Keypad_u8RowsCounter], !KEYPAD_u8PRESSEDSTATE);
}
}
for (u8 Keypad_u8ColumnsCounter = 0; Keypad_u8ColumnsCounter < KEYPAD_u8NUM_COLUMNS;
Keypad_u8ColumnsCounter++)
{
/*Comment!: Get Switch Index */
/*Comment!: Switch Index from 0~15*/
local_u8SwitchIdx = Keypad_u8ColumnsCounter + (KEYPAD_u8NUM_ROWS * Keypad_u8LoopCounter);
/*Comment!: Read Switch value*/
DIO_u8ReadPinVal(Keypad_u8COLUMNS_Array[Keypad_u8ColumnsCounter], &local_u8Switch_Current_State);
if (local_u8Switch_Current_State == KEYPAD_u8PRESSEDSTATE)
{
SET_BIT(Keypad_u16State.KEYPAD_u16Switches, local_u8SwitchIdx);
}
else
{
CLR_BIT(Keypad_u16State.KEYPAD_u16Switches, local_u8SwitchIdx);
}
}
}
return Keypad_u16State;
}
int main()
{
u8 local_u8state = STARTING_POINT;
u8 local_u8SwitchRead;
u16 local_u16Counter;
u8 local_Direction_Flag = RIGHT;
u16 local_stepper_counter = 0;
u8 local_Display_Flag = DISPLAY_OFF;
Keypad_u16Switches keypad;
u8 local_u8Switch_Pressed_num = STOP_SWITCH_INDEX;
u8 local_u8MotorPin1Val[2] =
{
DIO_u8HIGH, DIO_u8LOW
};
u8 LOCAL_U8DirectionMATRIX[3][8] =
{
{
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7C
},
{
0x78, 0x44, 0x48, 0x70, 0x70, 0x48, 0x44, 0x42
},
{
0, 0, 0, 0, 0, 0, 0, 0
}
};
/*Comment!:calling initialization functions */
DIO_voidInit();
TACTILE_SWITCH_voidInit();
KEYPAD_voidInit();
/*Comment!: use pull up resistors on portc*/
/*Comment!: this is against design rules but i had to use this way because there weren't pull up resistors on hardware*/
*DIO_u8PORTC = 0x0f;
/*Comment!:shift register work at rising edge so sh,st must be low before writing to shift register */
DIO_u8WritePinVal(SH_CP, DIO_u8LOW);
DIO_u8WritePinVal(ST_CP, DIO_u8LOW);
while (1)
{
/*Comment!:Display at Dot Matrix */
for (u8 local_u8RowsLoopCounter = 0; local_u8RowsLoopCounter < 8; local_u8RowsLoopCounter++)
{
/*Comment!:active one row each time */
for (u8 local_u8RowIndex = 0; local_u8RowIndex < 8; local_u8RowIndex++)
{
/*Comment!:write bit to shift register */
if (local_u8RowIndex != local_u8RowsLoopCounter)
{
DIO_u8WritePinVal(DS,
DIO_u8HIGH);
}
else
{
DIO_u8WritePinVal(DS,
DIO_u8LOW);
}
DIO_u8WritePinVal(SH_CP, DIO_u8HIGH);
DIO_u8WritePinVal(SH_CP, DIO_u8LOW);
}
/*Comment!:Write column */
for (u8 local_u8ColumnsLoopCounter = 0; local_u8ColumnsLoopCounter < 8; local_u8ColumnsLoopCounter++)
{
/*Comment!:write bit to shift register */
DIO_u8WritePinVal(DS,
GET_BIT(LOCAL_U8DirectionMATRIX[local_Display_Flag][local_u8RowsLoopCounter],
local_u8ColumnsLoopCounter));
DIO_u8WritePinVal(SH_CP, DIO_u8HIGH);
DIO_u8WritePinVal(SH_CP, DIO_u8LOW);
}
/*Comment!:latch Rows and Columns to dot matrix */
DIO_u8WritePinVal(ST_CP, DIO_u8HIGH);
DIO_u8WritePinVal(ST_CP, DIO_u8LOW);
}
/*comment!: end of displaying one column*/
/*Comment!:read Keypad*/
keypad = KEYPAD_Keypad_u16SwitchesRead();
/*Comment!:Check if switch pressed */
if (keypad.KEYPAD_u16Switches)
{
/*Comment!:get number of pressed switch */
local_u8Switch_Pressed_num = Stepper_16_Switch_Number(keypad.KEYPAD_u16Switches);
}
else
{
}
if ((local_u8Switch_Pressed_num < local_stepper_counter) && local_u8Switch_Pressed_num != STOP_SWITCH_INDEX)
{
Stepper_voidRotate();
local_stepper_counter = 0;
}
else if (local_u8Switch_Pressed_num != STOP_SWITCH_INDEX)
{
local_stepper_counter++;
}
else
{
}
/*Comment!:read switch */
TACTILE_SWITCH_u8Read(TACTILE_SWITCH_u8SWITCH1ID, &local_u8SwitchRead);
switch (local_u8state)
{
case STARTING_POINT:
if (local_u8SwitchRead == TACTILE_SWITCH_u8PRESSED)
{
/*Comment!:Rotate Motor */
DIO_u8WritePinVal(DIO_u8PIN8, local_u8MotorPin1Val[local_Direction_Flag]);
DIO_u8WritePinVal(DIO_u8PIN9, !local_u8MotorPin1Val[local_Direction_Flag]);
/*Comment!:Change State */
local_u8state = SWITCH_PRESSED;
/*Comment!:Change direction at display */
local_Display_Flag = local_Direction_Flag;
/*Comment!:Reset Time Counter */
local_u16Counter = 0;
}
else if (local_u8SwitchRead != TACTILE_SWITCH_u8PRESSED)
{
/*Comment!:Stop motor */
DIO_u8WritePinVal(DIO_u8PIN8, DIO_u8HIGH);
DIO_u8WritePinVal(DIO_u8PIN9, DIO_u8HIGH);
/*Comment!:Turn off dot matrix*/
local_Display_Flag = DISPLAY_OFF;
}
else
{
}
break;
case SWITCH_PRESSED:
/*Comment!:increment counter that represents time */
local_u16Counter++;
if (local_u8SwitchRead != TACTILE_SWITCH_u8PRESSED)
{
/*Comment!:Checking time */
if (local_u16Counter <= TIME_LIMIT)
{
/*Comment!:change state*/
local_u8state = CONTINOUS_MODE;
}
else
{
/*Comment!:Change direction*/
local_Direction_Flag = !local_Direction_Flag;
/*Comment!:change state*/
local_u8state = STARTING_POINT;
}
}
else
{
}
break;
case CONTINOUS_MODE:
/*Comment!:Rotate Motor*/
DIO_u8WritePinVal(DIO_u8PIN8, local_u8MotorPin1Val[local_Direction_Flag]);
DIO_u8WritePinVal(DIO_u8PIN9, !local_u8MotorPin1Val[local_Direction_Flag]);
if (local_u8SwitchRead == TACTILE_SWITCH_u8PRESSED)
{
/*Comment!:stop motor*/
DIO_u8WritePinVal(DIO_u8PIN8, DIO_u8HIGH);
DIO_u8WritePinVal(DIO_u8PIN9, DIO_u8HIGH);
/*Comment!:change state*/
local_u8state = WAITING_FOR_SWITCH_RELEASE;
}
else
{
}
break;
case WAITING_FOR_SWITCH_RELEASE:
/*Comment!:waiting for switch release*/
if (local_u8SwitchRead != TACTILE_SWITCH_u8PRESSED)
{
local_u8state = STARTING_POINT;
}
else
{
}
break;
default:
break;
}
}
return 0;
}
extern void RTOS_RedOffTask(void)
{
DIO_u8WritePinVal(RTOS_u8RedLed,RTOS_u8LedOff);
}
extern void RTOS_GreenOffTask(void)
{
DIO_u8WritePinVal(RTOS_u8GreenLed,RTOS_u8LedOff);
}
