３．４．16_プログラムリストNo.2(VOICERECORDER_User.c)

修正箇所(自動生成ファイルに記述追加)は、以下の青色の箇所です。
#include "C:\\WIZ_C\\Ver12\\Projects\\VOICERECORDER\\VOICERECORDER_Auto.h"
#include "C:\\WIZ_C\\Ver12\\Projects\\VOICERECORDER\\I2C.h"

#include <stdlib.h>
#include <Strings.h>
#include <Delays.h>

#__config _CONFIG1H, 0x02
#__config _CONFIG1L, 0x00
#__config _CONFIG2H, 0x0E
#__config _CONFIG2L, 0x0E
#__config _CONFIG3H, 0x01
#__config _CONFIG3L, 0x00
#__config _CONFIG4H, 0x00
#__config _CONFIG4L, 0x80

#define TST_TMR2IF (PIR1&(1<<TMR2IF))　　　　　　　　// TMR2IFフラグチェック
#define CLR_TMR2IF (PIR1&=~(1<<TMR2IF))　　　　　　　　// TMR2IFフラグクリア
#define TIMER2_ON T2CON|=(1<<TMR2ON)　　　　　　　　// TIMER2 START
#define TIMER2_OFF T2CON&=~(1<<TMR2ON)　　　　　　　　// TIMER2 STOP

#define DI_TMR2 (PIE1&=~(1<<TMR2IE))　　　　// TMR2割込禁止
#define EI_TMR2 (PIE1|=(1<<TMR2IE))　　　　　　　　// TMR2割込許可

WORD　　　　VR_PV, VR_PV_Work, VR_PV_Work_pre, EEReadWriteNo, EEReadWriteEnd;
BYTE　　　　out_str1[17], out_str2[17], data_buf[17], Transmit_Buf[32], Receive_Buf[32], EE_Work[2], EE_Buf0[256], EE_Buf1[256];
BYTE　　　　VR_PV_H, VR_PV_L, uadrs, SampMode, SampMode_Set, SampNo, StrCount, SetModeNo, EEBufCount, EE_BufNo;
bit　　　　No1Key, No2Key, No3Key, No4Key, UpKey, DownKey, LeftKey, RightKey, ModeKey, SetKey, Hosyu1Key, Hosyu2Key, SetMode;
bit　　　　EERead, EEWrite;

void IntTMR2();
void I2C_ROM_AdrsSet_1(BYTE uadrs, WORD adrs);
void I2C_ROM_Write_1(BYTE uadrs, WORD adrs, BYTE *data, WORD size);
void I2C_ROM_Read_1(BYTE uadrs, WORD adrs, BYTE *data, WORD size);
void I2C_ROM_AdrsSet_2(BYTE uadrs, WORD adrs);
void I2C_ROM_Write_2(BYTE uadrs, WORD adrs, BYTE *data, WORD size);
void I2C_ROM_Read_2(BYTE uadrs, WORD adrs, BYTE *data, WORD size);
void I2C_ROM_AdrsSet_3(BYTE uadrs, WORD adrs);
void I2C_ROM_Write_3(BYTE uadrs, WORD adrs, BYTE *data, WORD size);
void I2C_ROM_Read_3(BYTE uadrs, WORD adrs, BYTE *data, WORD size);
void EE_Start(WORD EENo);
void EE_Write(WORD EENo, BYTE EE_BufNo);
void EE_BufRead(WORD EENo, BYTE *data, BYTE EndData);
void EE_Stop(WORD EENo);
void TxStr(BYTE *Transmit_Buf);
void CmdProc();
void LCDdisp();
void LCDset();

//
// This file includes all user definable routines. It may be changed at will as
// it will not be regenerated once the application has been generated for the
// first time.
//

//*******************************************************************************
//
// Insert your interrupt handling code if required here.
// Note quick interrupts are used so code must be simple
// See the manual for details of quick interrupts.
//

void UserInterrupt()
{
　　　　// Insert your code here
　　　　// 500us周期
　　　　if(PIE1&(1<<TMR2IE))
　　　　{
　　　　　　　　if(TST_TMR2IF)
　　　　　　　　{　　　　　　　　　　　　// TIMER2 OverFlow T=499us
　　　　　　　　　　　　CLR_TMR2IF;
　　　　　　　　　　　　IntTMR2();
　　　　　　　　}
　　　　}

#asmline goto UserIntReturn　　　　; PIC Assembler - go back to interrupt routine
}


//*******************************************************************************
//
// Insert your initialisation code if required here.
// Note that when this routine is called Interrupts will not be enabled - the
// Application Designer will enable them before the main loop
//

void UserInitialise()
{
　　　　SampMode = ReadEEData(0);
　　　　if(SampMode == 0)
　　　　　　　　SampMode = 1;
　　　　if(SampMode > 3)
　　　　　　　　SampMode = 1;
　　　　SetPWM2Volts(0);
　　　　LCDClear();
　　　　ADCON0 |= (1<<GO);
　　　　
　　　　TIMER2_OFF;
　　　　EI_TMR2;
　　　　sprintf(out_str1,"VOICE RECORDER ");
　　　　sprintf(out_str2," ");
　　　　LCDdisp();
　　　　SetModeNo = 0;
　　　　EEBufCount = 0;

}

//*******************************************************************************
//
// Insert your main loop code if required here. This routine will be called
// as part of the main loop code
//

void UserLoop()
{
　　　　if(ModeKey)
　　　　{
　　　　　　　　ModeKey = 0;
　　　　　　　　if(SetMode)
　　　　　　　　　　　　SetMode = 0;
　　　　　　　　else
　　　　　　　　　　　　SetMode = 1;
　　　　　　　　if(SetMode)
　　　　　　　　{
　　　　　　　　　　　　No1Key = 0;
　　　　　　　　　　　　No2Key = 0;
　　　　　　　　　　　　No3Key = 0;
　　　　　　　　　　　　No4Key = 0;
　　　　　　　　　　　　UpKey = 0;
　　　　　　　　　　　　DownKey = 0;
　　　　　　　　　　　　LeftKey = 0;
　　　　　　　　　　　　RightKey = 0;
　　　　　　　　　　　　SetKey = 0;
　　　　　　　　　　　　SampNo = 0;
　　　　　　　　　　　　TIMER2_ON;
　　　　　　　　　　　　SetModeNo = 1;
　　　　　　　　　　　　sprintf(out_str1,"VOICE REC:MODE %d",SampMode);
　　　　　　　　　　　　switch(SampMode)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　case 1:sprintf(out_str2,"PUSH KEY(K1)! ");break;
　　　　　　　　　　　　　　　　case 2:sprintf(out_str2,"PUSH KEY(K1,K2)!");break;
　　　　　　　　　　　　　　　　case 3:sprintf(out_str2,"PUSH KEY(K1-K4)!");break;
　　　　　　　　　　　　　　　　default:sprintf(out_str2,"NOT SAMP MODE! ");
　　　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　else
　　　　　　　　{
　　　　　　　　　　　　TIMER2_OFF;
　　　　　　　　　　　　SetPWM2Volts(0);
　　　　　　　　　　　　SetModeNo = 0;
　　　　　　　　　　　　sprintf(out_str1,"VOICE RECORDER ");
　　　　　　　　　　　　sprintf(out_str2," ");
　　　　　　　　}
　　　　　　　　EERead = 0;
　　　　　　　　EEWrite = 0;
　　　　　　　　LCDClear();
　　　　　　　　LCDdisp();
　　　　}

　　　　if(No1Key)
　　　　{
　　　　　　　　No1Key = 0;
　　　　　　　　if(SetModeNo != 2)
　　　　　　　　{
　　　　　　　　　　　　if(SampMode == 1)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SampNo = 1;
　　　　　　　　　　　　　　　　EEReadWriteNo = 1;
　　　　　　　　　　　　　　　　EEReadWriteEnd = 1500;
　　　　　　　　　　　　　　　　sprintf(out_str2,"K1 (96sec) ");
　　　　　　　　　　　　}
　　　　　　　　　　　　if(SampMode == 2)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SampNo = 2;
　　　　　　　　　　　　　　　　EEReadWriteNo = 1;
　　　　　　　　　　　　　　　　EEReadWriteEnd = 750;
　　　　　　　　　　　　　　　　sprintf(out_str2,"K1 (48sec) ");
　　　　　　　　　　　　}
　　　　　　　　　　　　if(SampMode == 3)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SampNo = 4;
　　　　　　　　　　　　　　　　EEReadWriteNo = 1;
　　　　　　　　　　　　　　　　EEReadWriteEnd = 375;
　　　　　　　　　　　　　　　　sprintf(out_str2,"K1 (24sec) ");
　　　　　　　　　　　　}
　　　　　　　　　　　　LCDdisp();
　　　　　　　　　　　　if(SetMode)
　　　　　　　　　　　　　　　　EEWrite = 1;
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　EERead = 1;
　　　　　　　　　　　　　　　　TIMER2_ON;
　　　　　　　　　　　　　　　　EE_Start(EEReadWriteNo);
　　　　　　　　　　　　}
　　　　　　　　　　　　EEBufCount = 0;
　　　　　　　　}
　　　　}
　　　　
　　　　if(No2Key)
　　　　{
　　　　　　　　No2Key = 0;
　　　　　　　　if(SetModeNo != 2)
　　　　　　　　{
　　　　　　　　　　　　if(SampMode == 2)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SampNo = 3;
　　　　　　　　　　　　　　　　EEReadWriteNo = 751;
　　　　　　　　　　　　　　　　EEReadWriteEnd = 1500;
　　　　　　　　　　　　　　　　sprintf(out_str2,"K2 (48sec) ");
　　　　　　　　　　　　}
　　　　　　　　　　　　if(SampMode == 3)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SampNo = 5;
　　　　　　　　　　　　　　　　EEReadWriteNo = 376;
　　　　　　　　　　　　　　　　EEReadWriteEnd = 750;
　　　　　　　　　　　　　　　　sprintf(out_str2,"K2 (24sec) ");
　　　　　　　　　　　　}
　　　　　　　　　　　　LCDdisp();
　　　　　　　　　　　　if(SetMode)
　　　　　　　　　　　　　　　　EEWrite = 1;
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　EERead = 1;
　　　　　　　　　　　　　　　　TIMER2_ON;
　　　　　　　　　　　　　　　　EE_Start(EEReadWriteNo);
　　　　　　　　　　　　}
　　　　　　　　　　　　EEBufCount = 0;
　　　　　　　　}
　　　　}
　　　　
　　　　if(No3Key)
　　　　{
　　　　　　　　No3Key = 0;
　　　　　　　　if(SetModeNo != 2)
　　　　　　　　{
　　　　　　　　　　　　if(SampMode == 3)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SampNo = 6;
　　　　　　　　　　　　　　　　EEReadWriteNo = 751;
　　　　　　　　　　　　　　　　EEReadWriteEnd = 1125;
　　　　　　　　　　　　　　　　sprintf(out_str2,"K3 (24sec) ");
　　　　　　　　　　　　}
　　　　　　　　　　　　LCDdisp();
　　　　　　　　　　　　if(SetMode)
　　　　　　　　　　　　　　　　EEWrite = 1;
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　EERead = 1;
　　　　　　　　　　　　　　　　TIMER2_ON;
　　　　　　　　　　　　　　　　EE_Start(EEReadWriteNo);
　　　　　　　　　　　　}
　　　　　　　　　　　　EEBufCount = 0;
　　　　　　　　}
　　　　}
　　　　
　　　　if(No4Key)
　　　　{
　　　　　　　　No4Key = 0;
　　　　　　　　if(SetModeNo != 2)
　　　　　　　　{
　　　　　　　　　　　　if(SampMode == 3)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SampNo = 7;
　　　　　　　　　　　　　　　　EEReadWriteNo = 1126;
　　　　　　　　　　　　　　　　EEReadWriteEnd = 1500;
　　　　　　　　　　　　　　　　sprintf(out_str2,"K4 (24sec) ");
　　　　　　　　　　　　}
　　　　　　　　　　　　LCDdisp();
　　　　　　　　　　　　if(SetMode)
　　　　　　　　　　　　　　　　EEWrite = 1;
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　EERead = 1;
　　　　　　　　　　　　　　　　TIMER2_ON;
　　　　　　　　　　　　　　　　EE_Start(EEReadWriteNo);
　　　　　　　　　　　　}
　　　　　　　　　　　　EEBufCount = 0;
　　　　　　　　}
　　　　}

　　　　if(SetMode)
　　　　{
　　　　　　　　if(LeftKey)
　　　　　　　　{
　　　　　　　　　　　　LeftKey = 0;
　　　　　　　　　　　　if(SetModeNo == 1)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SetModeNo = 2;
　　　　　　　　　　　　　　　　SampMode_Set = SampMode;
　　　　　　　　　　　　　　　　sprintf(out_str1,"SET SAMP MODE %d ",SampMode_Set);
　　　　　　　　　　　　　　　　switch(SampMode_Set)
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　case 1:sprintf(out_str2,"USE KEY (K1) ");break;
　　　　　　　　　　　　　　　　　　　　case 2:sprintf(out_str2,"USE KEY (K1,K2) ");break;
　　　　　　　　　　　　　　　　　　　　case 3:sprintf(out_str2,"USE KEY (K1-K4) ");break;
　　　　　　　　　　　　　　　　　　　　default:sprintf(out_str2,"NOT SAMP MODE! ");
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　LCDset();
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SetModeNo = 1;
　　　　　　　　　　　　　　　　sprintf(out_str1,"VOICE REC:MODE %d",SampMode);
　　　　　　　　　　　　　　　　switch(SampMode)
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　case 1:sprintf(out_str2,"PUSH KEY(K1)! ");break;
　　　　　　　　　　　　　　　　　　　　case 2:sprintf(out_str2,"PUSH KEY(K1,K2)!");break;
　　　　　　　　　　　　　　　　　　　　case 3:sprintf(out_str2,"PUSH KEY(K1-K4)!");break;
　　　　　　　　　　　　　　　　　　　　default:sprintf(out_str2,"NOT SAMP MODE! ");
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　LCDdisp();
　　　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　
　　　　　　　　if(RightKey)
　　　　　　　　{
　　　　　　　　　　　　RightKey = 0;
　　　　　　　　　　　　if(SetModeNo == 1)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SetModeNo = 2;
　　　　　　　　　　　　　　　　SampMode_Set = SampMode;
　　　　　　　　　　　　　　　　sprintf(out_str1,"SET SAMP MODE %d ",SampMode_Set);
　　　　　　　　　　　　　　　　switch(SampMode_Set)
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　case 1:sprintf(out_str2,"USE KEY (K1) ");break;
　　　　　　　　　　　　　　　　　　　　case 2:sprintf(out_str2,"USE KEY (K1,K2) ");break;
　　　　　　　　　　　　　　　　　　　　case 3:sprintf(out_str2,"USE KEY (K1-K4) ");break;
　　　　　　　　　　　　　　　　　　　　default:sprintf(out_str2,"NOT SAMP MODE! ");
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　LCDset();
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　SetModeNo = 1;
　　　　　　　　　　　　　　　　sprintf(out_str1,"VOICE REC:MODE %d",SampMode);
　　　　　　　　　　　　　　　　switch(SampMode)
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　case 1:sprintf(out_str2,"PUSH KEY(K1)! ");break;
　　　　　　　　　　　　　　　　　　　　case 2:sprintf(out_str2,"PUSH KEY(K1,K2)!");break;
　　　　　　　　　　　　　　　　　　　　case 3:sprintf(out_str2,"PUSH KEY(K1-K4)!");break;
　　　　　　　　　　　　　　　　　　　　default:sprintf(out_str2,"NOT SAMP MODE! ");
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　LCDdisp();
　　　　　　　　　　　　}
　　　　　　　　}
　　　　
　　　　　　　　if(UpKey)
　　　　　　　　{
　　　　　　　　　　　　UpKey = 0;
　　　　　　　　　　　　if(SetModeNo == 2)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　if(SampMode_Set >= 3)
　　　　　　　　　　　　　　　　　　　　SampMode_Set = 1;
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　SampMode_Set = SampMode_Set + 1;
　　　　　　　　　　　　}
　　　　　　　　　　　　sprintf(out_str1,"SET SAMP MODE %d ",SampMode_Set);
　　　　　　　　　　　　switch(SampMode_Set)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　case 1:sprintf(out_str2,"USE KEY (K1) ");break;
　　　　　　　　　　　　　　　　case 2:sprintf(out_str2,"USE KEY (K1,K2) ");break;
　　　　　　　　　　　　　　　　case 3:sprintf(out_str2,"USE KEY (K1-K4) ");break;
　　　　　　　　　　　　　　　　default:sprintf(out_str2,"NOT SAMP MODE! ");
　　　　　　　　　　　　}
　　　　　　　　　　　　if(SetModeNo == 2)
　　　　　　　　　　　　　　　　LCDset();
　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　LCDdisp();
　　　　　　　　}
　　　　　　　　
　　　　　　　　if(DownKey)
　　　　　　　　{
　　　　　　　　　　　　DownKey = 0;
　　　　　　　　　　　　if(SetModeNo == 2)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　if(SampMode_Set <= 1)
　　　　　　　　　　　　　　　　　　　　SampMode_Set = 3;
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　SampMode_Set = SampMode_Set - 1;
　　　　　　　　　　　　}
　　　　　　　　　　　　sprintf(out_str1,"SET SAMP MODE %d ",SampMode_Set);
　　　　　　　　　　　　switch(SampMode_Set)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　case 1:sprintf(out_str2,"USE KEY (K1) ");break;
　　　　　　　　　　　　　　　　case 2:sprintf(out_str2,"USE KEY (K1,K2) ");break;
　　　　　　　　　　　　　　　　case 3:sprintf(out_str2,"USE KEY (K1-K4) ");break;
　　　　　　　　　　　　　　　　default:sprintf(out_str2,"NOT SAMP MODE! ");
　　　　　　　　　　　　}
　　　　　　　　　　　　if(SetModeNo == 2)
　　　　　　　　　　　　　　　　LCDset();
　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　LCDdisp();
　　　　　　　　}
　　　　　　　　
　　　　　　　　if(SetKey)
　　　　　　　　{
　　　　　　　　　　　　SetKey = 0;
　　　　　　　　　　　　if(SetModeNo == 2)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　TIMER2_OFF;
　　　　　　　　　　　　　　　　SetPWM2Volts(0);
　　　　　　　　　　　　　　　　SetMode = 0;
　　　　　　　　　　　　　　　　SetModeNo = 0;
　　　　　　　　　　　　　　　　EERead = 0;
　　　　　　　　　　　　　　　　EEWrite = 0;
　　　　　　　　　　　　　　　　SampMode = SampMode_Set;
　　　　　　　　　　　　　　　　WriteEEData(0, SampMode);
　　　　　　　　　　　　　　　　sprintf(out_str1,"VOICE RECORDER ");
　　　　　　　　　　　　　　　　sprintf(out_str2," ");
　　　　　　　　　　　　}
　　　　　　　　　　　　LCDdisp();
　　　　　　　　}
　　　　}

　　　　if(Hosyu1Key)
　　　　　　　　Hosyu1Key = 0;

　　　　if(Hosyu2Key)
　　　　　　　　Hosyu2Key = 0;
}

//
// User occurrence code
//

void IntTMR2()
{
　　　　ADCON0 |= (1<<GO);
　　　　if(SetMode)
　　　　{
　　　　　　　　VR_PV = VR_PV_Work;
　　　　　　　　SetPWM2Volts(VR_PV);
　　　　　　　　if(EEWrite)
　　　　　　　　{
　　　　　　　　　　　　if(EE_BufNo == 0)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　EE_Buf0[EEBufCount] = VR_PV_L;
　　　　　　　　　　　　　　　　EEBufCount = EEBufCount + 1;
　　　　　　　　　　　　　　　　EE_Buf0[EEBufCount] = VR_PV_H;
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　EE_Buf1[EEBufCount] = VR_PV_L;
　　　　　　　　　　　　　　　　EEBufCount = EEBufCount + 1;
　　　　　　　　　　　　　　　　EE_Buf1[EEBufCount] = VR_PV_H;
　　　　　　　　　　　　}
　　　　　　　　　　　　if(EEBufCount == 255)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　EEBufCount = 0;
　　　　　　　　　　　　　　　　EE_Write(EEReadWriteNo, EE_BufNo);
　　　　　　　　　　　　　　　　if(EE_BufNo == 0)
　　　　　　　　　　　　　　　　　　　　EE_BufNo = 1;
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　EE_BufNo = 0;
　　　　　　　　　　　　　　　　if(EEReadWriteNo == EEReadWriteEnd)
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　EEWrite = 0;
　　　　　　　　　　　　　　　　　　　　switch(SampMode)
　　　　　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　　　　　case 1:sprintf(out_str2,"PUSH KEY(K1)! ");break;
　　　　　　　　　　　　　　　　　　　　　　　　case 2:sprintf(out_str2,"PUSH KEY(K1,K2)!");break;
　　　　　　　　　　　　　　　　　　　　　　　　case 3:sprintf(out_str2,"PUSH KEY(K1-K4)!");break;
　　　　　　　　　　　　　　　　　　　　　　　　default:sprintf(out_str2,"NOT SAMP MODE! ");
　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　EEReadWriteNo = EEReadWriteNo + 1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　EEBufCount = EEBufCount + 1;
　　　　　　　　}　　　　
　　　　}
　　　　else
　　　　{
　　　　　　　　if(EERead)
　　　　　　　　{
　　　　　　　　　　　　if(EEBufCount == 127)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　EE_BufRead(EEReadWriteNo, EE_Work, 1);
　　　　　　　　　　　　　　　　VR_PV_L = EE_Work[0];
　　　　　　　　　　　　　　　　VR_PV_H = EE_Work[1];
　　　　　　　　　　　　　　　　VR_PV_Work = (WORD)VR_PV_H << 8;
　　　　　　　　　　　　　　　　VR_PV_Work = VR_PV_Work | VR_PV_L;
　　　　　　　　　　　　　　　　SetPWM2Volts(VR_PV_Work);
　　　　　　　　　　　　　　　　EEBufCount = 0;
　　　　　　　　　　　　　　　　EE_Stop(EEReadWriteNo);
　　　　　　　　　　　　　　　　if(EEReadWriteNo == EEReadWriteEnd)
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　EERead = 0;
　　　　　　　　　　　　　　　　　　　　sprintf(out_str2," ");
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　EEReadWriteNo = EEReadWriteNo + 1;
　　　　　　　　　　　　　　　　　　　　EE_Start(EEReadWriteNo);
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　EE_BufRead(EEReadWriteNo, EE_Work, 0);
　　　　　　　　　　　　　　　　VR_PV_L = EE_Work[0];
　　　　　　　　　　　　　　　　VR_PV_H = EE_Work[1];　　　　　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　VR_PV_Work = (WORD)VR_PV_H << 8;
　　　　　　　　　　　　　　　　VR_PV_Work = VR_PV_Work | VR_PV_L;
　　　　　　　　　　　　　　　　SetPWM2Volts(VR_PV_Work);
　　　　　　　　　　　　　　　　EEBufCount = EEBufCount + 1;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

//
// Occurrence - A key has been pressed (or is repeating)
//

void KeyPress()
{
　　　　switch(KP4Value)
　　　　{
　　　　　　　　case 0:No1Key = 1;break;
　　　　　　　　case 1:No2Key = 1;break;
　　　　　　　　case 2:No3Key = 1;break;
　　　　　　　　case 3:No4Key = 1;break;
　　　　　　　　case 4:UpKey = 1;break;
　　　　　　　　case 5:DownKey = 1;break;
　　　　　　　　case 6:LeftKey = 1;break;
　　　　　　　　case 7:RightKey = 1;break;
　　　　　　　　case 8:ModeKey = 1;break;
　　　　　　　　case 9:SetKey = 1;break;
　　　　　　　　case 10:Hosyu1Key = 1;break;
　　　　　　　　case 11:Hosyu2Key = 1;break;
　　　　}
}

//
// Occurrence - Byte received on serial interface
//

void GetRX()
{
　　　　BYTE ch;
　　　　if(GetRxSize() > 0)
　　　　{
　　　　　　　　ch = WaitRx();
　　　　　　　　if((ch == '\r') || (ch == '\n'))　　　　　　　　　　　　　　　　//'\r'(0x0D)
　　　　　　　　{
　　　　　　　　　　　　Receive_Buf[StrCount] = 0;　　　　//NULL
　　　　　　　　　　　　StrCount = 0;
　　　　　　　　　　　　CmdProc();
　　　　　　　　}
　　　　　　　　else
　　　　　　　　{
　　　　　　　　　　　　Receive_Buf[StrCount] = ch;
　　　　　　　　　　　　StrCount = StrCount + 1;
　　　　　　　　　　　　if(StrCount > 7)
　　　　　　　　　　　　　　　　StrCount = 7;
　　　　　　　　}
　　　　}
}

void CmdProc()
{
　　　　if(strcmp(Receive_Buf,"SAR1") == 0)
　　　　{
　　　　　　　　TxStr("123456\r\n");
　　　　}

　　　　if(strcmp(Receive_Buf,"SAR2") == 0)
　　　　{
　　　　　　　　TxStr("ABCDEF\r\n");
　　　　}

　　　　strcpy(Receive_Buf,"");
　　　　StrCount = 0;
}

void TxStr(BYTE *Transmit_Buf)
{
　　　　BYTE i;
　　　　for(i = 0; i < 8; i++)　　　　　　　　　　　　//8byte送信
　　　　　　　　AddTx(Transmit_Buf[i]);
}

void LCDdisp()
{
　　　　//LCD display
　　　　LCDPrintAt(0,0);
　　　　LCDString(out_str1);
　　　　LCDPrintAt(0,1);
　　　　LCDString(out_str2);
}

void LCDset()
{
　　　　//LCD display
　　　　LCDPrintAt(0,0);
　　　　LCDString(out_str1);
　　　　LCDPrintAt(0,1);
　　　　LCDString(out_str2);
　　　　LCDPrintAt(14, 0);
　　　　LCDOnOff(1, 0, 1);
}

//
// Occurrence - A/D Conversion complete
//

void ad_data_t()
{
　　　　VR_PV_L = ADRESL;
　　　　VR_PV_H = ADRESH;
　　　　VR_PV_Work = (WORD)ADRESH << 8;
　　　　VR_PV_Work = VR_PV_Work | ADRESL;
}

//
//I2C-EEPROM DATA WRITE(EENo:1〜1500, data:fix 256byte)
//
void EE_Write(WORD EENo, BYTE EE_BufNo)
{
　　　　if(EENo >= 1)
　　　　{
　　　　　　　　if(EENo <= 1500)
　　　　　　　　{
　　　　　　　　　　　　BYTE uadrs;
　　　　　　　　　　　　WORD adrs;
　　　　　　　　　　　　if(EENo<=500)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　if(EENo <= 250)
　　　　　　　　　　　　　　　　　　　　uadrs = 0;
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　uadrs = 1;
　　　　　　　　　　　　　　　　adrs = (EENo - 1) * 256;
　　　　　　　　　　　　　　　　if(EE_BufNo == 0)
　　　　　　　　　　　　　　　　　　　　I2C_ROM_Write_1(uadrs, adrs, EE_Buf0, 256);
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　I2C_ROM_Write_1(uadrs, adrs, EE_Buf1, 256);
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　if(EENo <= 1000)
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　if(EENo <= 750)
　　　　　　　　　　　　　　　　　　　　　　　　uadrs = 0;
　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　uadrs = 1;
　　　　　　　　　　　　　　　　　　　　adrs = (EENo - 1) * 256;
　　　　　　　　　　　　　　　　　　　　if(EE_BufNo == 0)
　　　　　　　　　　　　　　　　　　　　　　　　I2C_ROM_Write_2(uadrs, adrs, EE_Buf0, 256);
　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　I2C_ROM_Write_2(uadrs, adrs, EE_Buf1, 256);
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　if(EENo <= 1250)
　　　　　　　　　　　　　　　　　　　　　　　　uadrs = 0;
　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　uadrs = 1;
　　　　　　　　　　　　　　　　　　　　adrs = (EENo - 1) * 256;
　　　　　　　　　　　　　　　　　　　　if(EE_BufNo == 0)
　　　　　　　　　　　　　　　　　　　　　　　　I2C_ROM_Write_3(uadrs, adrs, EE_Buf0, 256);
　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　I2C_ROM_Write_3(uadrs, adrs, EE_Buf1, 256);
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

//
//I2C EEPROM Start Process(EENo:1〜1500 : 256byte*1500)
//
void EE_Start(WORD EENo)
{
　　　　if(EENo >= 1)
　　　　{
　　　　　　　　if(EENo <= 1500)
　　　　　　　　{
　　　　　　　　　　　　BYTE uadrs;
　　　　　　　　　　　　WORD adrs;
　　　　　　　　　　　　if(EENo<=500)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　if(EENo <= 250)
　　　　　　　　　　　　　　　　　　　　uadrs = 0;
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　uadrs = 1;
　　　　　　　　　　　　　　　　adrs = (EENo - 1) * 256;
　　　　　　　　　　　　　　　　I2C_ROM_AdrsSet_1(uadrs, adrs);
　　　　　　　　　　　　　　　　if(EERead)
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　I2CStart_1(I2C_START_CONT);
　　　　　　　　　　　　　　　　　　　　if(uadrs == 0)
　　　　　　　　　　　　　　　　　　　　　　　　I2CWrite_1(0xA1);　　　　　　　　　　　　// control byte (read)
　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　I2CWrite_1(0xA3);　　　　　　　　　　　　// control byte (read)
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　if(EENo <= 1000)
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　if(EENo <= 750)
　　　　　　　　　　　　　　　　　　　　　　　　uadrs = 0;
　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　uadrs = 1;
　　　　　　　　　　　　　　　　　　　　adrs = (EENo - 1) * 256;
　　　　　　　　　　　　　　　　　　　　I2C_ROM_AdrsSet_2(uadrs, adrs);
　　　　　　　　　　　　　　　　　　　　if(EERead)
　　　　　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　　　　　I2CStart_2(I2C_START_CONT);
　　　　　　　　　　　　　　　　　　　　　　　　if(uadrs == 0)
　　　　　　　　　　　　　　　　　　　　　　　　　　　　I2CWrite_2(0xA1);　　　　　　　　　　　　// control byte (read)
　　　　　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　　　　　I2CWrite_2(0xA3);　　　　　　　　　　　　// control byte (read)
　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　if(EENo <= 1250)
　　　　　　　　　　　　　　　　　　　　　　　　uadrs = 0;
　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　uadrs = 1;
　　　　　　　　　　　　　　　　　　　　adrs = (EENo - 1) * 256;
　　　　　　　　　　　　　　　　　　　　I2C_ROM_AdrsSet_3(uadrs, adrs);
　　　　　　　　　　　　　　　　　　　　if(EERead)
　　　　　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　　　　　I2CStart_3(I2C_START_CONT);
　　　　　　　　　　　　　　　　　　　　　　　　if(uadrs == 0)
　　　　　　　　　　　　　　　　　　　　　　　　　　　　I2CWrite_3(0xA1);　　　　　　　　　　　　// control byte (read)
　　　　　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　　　　　I2CWrite_3(0xA3);　　　　　　　　　　　　// control byte (read)
　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

//
//I2C EEPROM 2byte Buffer Read Process(EENo:1〜1500 : 256byte*1500)
//
void EE_BufRead(WORD EENo, BYTE *data, BYTE EndData)
{
　　　　if(EENo >= 1)
　　　　{
　　　　　　　　if(EENo <= 1500)
　　　　　　　　{
　　　　　　　　　　　　if(EENo<=500)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　*data = I2CRead_1(I2C_READ_ACK);
　　　　　　　　　　　　　　　　data++;
　　　　　　　　　　　　　　　　if(EndData == 0)
　　　　　　　　　　　　　　　　　　　　*data = I2CRead_1(I2C_READ_ACK);
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　*data = I2CRead_1(I2C_READ_NOACK);
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　if(EENo <= 1000)
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　*data = I2CRead_2(I2C_READ_NOACK);
　　　　　　　　　　　　　　　　　　　　data++;
　　　　　　　　　　　　　　　　　　　　if(EndData == 0)
　　　　　　　　　　　　　　　　　　　　　　　　*data = I2CRead_2(I2C_READ_ACK);
　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　*data = I2CRead_2(I2C_READ_NOACK);
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　*data = I2CRead_3(I2C_READ_NOACK);
　　　　　　　　　　　　　　　　　　　　data++;
　　　　　　　　　　　　　　　　　　　　if(EndData == 0)
　　　　　　　　　　　　　　　　　　　　　　　　*data = I2CRead_3(I2C_READ_ACK);
　　　　　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　　　　　*data = I2CRead_3(I2C_READ_NOACK);
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

//
//I2C EEPROM Stop Process(EENo:1〜1500 : 256byte*1500)
//
void EE_Stop(WORD EENo)
{
　　　　if(EENo >= 1)
　　　　{
　　　　　　　　if(EENo <= 1500)
　　　　　　　　{
　　　　　　　　　　　　BYTE i;
　　　　　　　　　　　　if(EENo<=500)
　　　　　　　　　　　　　　　　I2CStop_1();
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　if(EENo <= 1000)
　　　　　　　　　　　　　　　　　　　　I2CStop_2();
　　　　　　　　　　　　　　　　else
　　　　　　　　　　　　　　　　　　　　I2CStop_3();
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

//**************************************************
// No.1 I2Cbus EEPROM
// SDA:RC0
// SCL:RA4
//**************************************************

//
// I2C-EEPROM DATA WRITE
//
void I2C_ROM_Write_1(BYTE uadrs, WORD adrs, BYTE *data, WORD size)
{
　　　　WORD i;
　　　　I2C_ROM_AdrsSet_1(uadrs, adrs);
　　　　for(i = 0; i < size; i++)
　　　　{
　　　　　　　　I2CWrite_1(*data);
　　　　　　　　data++;
　　　　}
　　　　I2CStop_1();
}

//
// I2C-EEPROM DATA READ
//
void I2C_ROM_Read_1(BYTE uadrs, WORD adrs, BYTE *data, WORD size)
{
　　　　WORD i;
　　　　I2C_ROM_AdrsSet_1(uadrs, adrs);
　　　　I2CStart_1(I2C_START_CONT);
　　　　if(uadrs == 0)
　　　　　　　　I2CWrite_1(0xA1);　　　　　　　　　　　　// control byte (read)
　　　　else
　　　　　　　　I2CWrite_1(0xA3);　　　　　　　　　　　　// control byte (read)
　　　　for(i = 0; i < size; i++)
　　　　{
　　　　　　　　if(i != (size - 1))
　　　　　　　　　　　　*data = I2CRead_1(I2C_READ_ACK);
　　　　　　　　else
　　　　　　　　　　　　*data = I2CRead_1(I2C_READ_NOACK);
　　　　　　　　data++;
　　　　}
　　　　I2CStop_1();
}

//
// I2C-EEPROM DATA READ/WRITE ADDRES SET
//
void I2C_ROM_AdrsSet_1(BYTE uadrs, WORD adrs)
{
　　　　I2CStart_1(I2C_START_NORM);
　　　　if(uadrs == 0)
　　　　　　　　I2CWrite_1(0xA0);　　　　　　　　　　　　// control byte (write)
　　　　else　　　　
　　　　　　　　I2CWrite_1(0xA2);　　　　　　　　　　　　// control byte (write)
　　　　I2CWrite_1(adrs>>8);　　　　　　　　　　　　// EEPROM Address(H)
　　　　I2CWrite_1(adrs);　　　　　　　　　　　　　　　　// EEPROM Address(L)
}

//**************************************************
// No.2 I2Cbus EEPROM
// SDA:RD1
// SCL:RD0
//**************************************************

//
// I2C-EEPROM DATA WRITE
//
void I2C_ROM_Write_2(BYTE uadrs, WORD adrs, BYTE *data, WORD size)
{
　　　　WORD i;
　　　　I2C_ROM_AdrsSet_2(uadrs, adrs);
　　　　for(i = 0; i < size; i++)
　　　　{
　　　　　　　　I2CWrite_2(*data);
　　　　　　　　data++;
　　　　}
　　　　I2CStop_2();
}

//
// I2C-EEPROM DATA READ
//
void I2C_ROM_Read_2(BYTE uadrs, WORD adrs, BYTE *data, WORD size)
{
　　　　WORD i;
　　　　I2C_ROM_AdrsSet_2(uadrs, adrs);
　　　　I2CStart_2(I2C_START_CONT);
　　　　if(uadrs == 0)
　　　　　　　　I2CWrite_2(0xA1);　　　　　　　　　　　　// control byte (read)
　　　　else
　　　　　　　　I2CWrite_2(0xA3);　　　　　　　　　　　　// control byte (read)
　　　　for(i = 0; i < size; i++)
　　　　{
　　　　　　　　if(i != (size - 1))
　　　　　　　　　　　　*data = I2CRead_2(I2C_READ_ACK);
　　　　　　　　else
　　　　　　　　　　　　*data = I2CRead_2(I2C_READ_NOACK);
　　　　　　　　data++;
　　　　}
　　　　I2CStop_2();
}

//
// I2C-EEPROM DATA READ/WRITE ADDRES SET
//
void I2C_ROM_AdrsSet_2(BYTE uadrs, WORD adrs)
{
　　　　I2CStart_2(I2C_START_NORM);
　　　　if(uadrs == 0)
　　　　　　　　I2CWrite_2(0xA0);　　　　　　　　　　　　// control byte (write)
　　　　else　　　　
　　　　　　　　I2CWrite_2(0xA2);　　　　　　　　　　　　// control byte (write)
　　　　I2CWrite_2(adrs>>8);　　　　　　　　　　　　// EEPROM Address(H)
　　　　I2CWrite_2(adrs);　　　　　　　　　　　　　　　　// EEPROM Address(L)
}

//**************************************************
// No.3 I2Cbus EEPROM
// SDA:RD3
// SCL:RD2
//**************************************************

//
// I2C-EEPROM DATA WRITE
//
void I2C_ROM_Write_3(BYTE uadrs, WORD adrs, BYTE *data, WORD size)
{
　　　　WORD i;
　　　　I2C_ROM_AdrsSet_3(uadrs, adrs);
　　　　for(i = 0; i < size; i++)
　　　　{
　　　　　　　　I2CWrite_3(*data);
　　　　　　　　data++;
　　　　}
　　　　I2CStop_3();
}

//
// I2C-EEPROM DATA READ
//
void I2C_ROM_Read_3(BYTE uadrs, WORD adrs, BYTE *data, WORD size)
{
　　　　WORD i;
　　　　I2C_ROM_AdrsSet_3(uadrs, adrs);
　　　　I2CStart_3(I2C_START_CONT);
　　　　if(uadrs == 0)
　　　　　　　　I2CWrite_3(0xA1);　　　　　　　　　　　　// control byte (read)
　　　　else
　　　　　　　　I2CWrite_3(0xA3);　　　　　　　　　　　　// control byte (read)
　　　　for(i = 0; i < size; i++)
　　　　{
　　　　　　　　if(i != (size - 1))
　　　　　　　　　　　　*data = I2CRead_3(I2C_READ_ACK);
　　　　　　　　else
　　　　　　　　　　　　*data = I2CRead_3(I2C_READ_NOACK);
　　　　　　　　data++;
　　　　}
　　　　I2CStop_3();
}

//
// I2C-EEPROM DATA READ/WRITE ADDRES SET
//
void I2C_ROM_AdrsSet_3(BYTE uadrs, WORD adrs)
{
　　　　I2CStart_3(I2C_START_NORM);
　　　　if(uadrs == 0)
　　　　　　　　I2CWrite_3(0xA0);　　　　　　　　　　　　// control byte (write)
　　　　else　　　　
　　　　　　　　I2CWrite_3(0xA2);　　　　　　　　　　　　// control byte (write)
　　　　I2CWrite_3(adrs>>8);　　　　　　　　　　　　// EEPROM Address(H)
　　　　I2CWrite_3(adrs);　　　　　　　　　　　　　　　　// EEPROM Address(L)
}

//**************************************************




トップページヘもどる