int main(int argc, char *argv[]) {
int i,j,k,portFD;
unsigned char data[1024];
gettimeofday(&tStart,NULL);
output(1,"HP iPAQ 214 BT chip GPIO twiddling util v1.1\n----------------------------------\n");
#ifndef NOIO
gpioInit(1);
#else
output(1,"TESTING MODE - NOT USING IO\n");
#endif
if(argc > 1 && strcmp(argv[1],"on")==0){
portFD=openPort();
if(portFD == -1){ return 0; }
output(1,"Shutting down chip first...\n");
#ifndef NOIO
shutdownChip();
tcflush(portFD, TCIOFLUSH); //flush buffers again
#endif
output(1,"Waiting 2 secs.\n");
sleep(2);
output(1,"Bringing up chip...\n");
bringUpChip();
output(1,"Resetting chip...\n");
#ifndef NOIO
sendReset(portFD);
#endif
output(1,"Turning LED on.\n");
#ifndef NOIO
gpioSet(3,1);
#endif
output(1,"closing port..."); fflush(stdout);
close(portFD);
output(1,"done\n");
}else if(argc > 1 && strcmp(argv[1],"off")==0){
output(1,"Shutting down chip...\n");
#ifndef NOIO
shutdownChip();
gpioSet(3,0); //turn LED off
#endif
}else
printf("usage %s on/off\n",argv[0]);
#ifndef NOIO
gpioCleanup();
#endif
return 0;
}
int main(void)
{
gpioConfig(N_LED_ORANGE_PORT, N_LED_ORANGE_PIN, GPIO_OUTPUT | GPIO_LOW);
gpioConfig(N_LED_YELLOW_PORT, N_LED_YELLOW_PIN, GPIO_OUTPUT | GPIO_LOW);
gpioConfig(N_LED_GREEN_PORT, N_LED_GREEN_PIN, GPIO_OUTPUT | GPIO_LOW);
gpioConfig(N_LED_BLUE_PORT, N_LED_BLUE_PIN, GPIO_OUTPUT | GPIO_LOW);
for (;;) {
delay();
gpioClear(N_LED_ORANGE_PORT, N_LED_ORANGE_PIN);
delay();
gpioClear(N_LED_YELLOW_PORT, N_LED_YELLOW_PIN);
delay();
gpioClear(N_LED_GREEN_PORT, N_LED_GREEN_PIN);
delay();
gpioClear(N_LED_BLUE_PORT, N_LED_BLUE_PIN);
delay();
gpioSet(N_LED_ORANGE_PORT, N_LED_ORANGE_PIN);
delay();
gpioSet(N_LED_YELLOW_PORT, N_LED_YELLOW_PIN);
delay();
gpioSet(N_LED_GREEN_PORT, N_LED_GREEN_PIN);
delay();
gpioSet(N_LED_BLUE_PORT, N_LED_BLUE_PIN);
}
return 0;
}
void apIntClear(bool wakeup)
{
if (wakeup)
gpioSet(apIntWkup, 1);
#ifdef AP_INT_NONWAKEUP
else
gpioSet(apIntNonWkup, 1);
#endif
}
static void flashLed(int port, int pin, int numBlinks)
{
int k;
for (k = 0; k < numBlinks; k++) {
gpioClear(port, pin);
delay();
gpioSet(port, pin);
delay();
}
}
static int stmSpiMasterStopSync(struct SpiDevice *dev)
{
struct StmSpiDev *pdev = dev->pdata;
if (pdev->nss) {
gpioSet(pdev->nss, 1);
gpioRelease(pdev->nss);
}
stmSpiDisable(dev, true);
pdev->nss = NULL;
return 0;
}
void shutdownChip(){
output(1,"Shutting down chip.\n");
gpioSet(81,0);
gpioSet(3,0);
gpioSet(53,0);
gpioSet(71,0);
gpioSet(124,0);
gpioSet(114,0);
}
static void stmSpiDone(struct StmSpiDev *pdev, int err)
{
struct StmSpi *regs = pdev->cfg->regs;
struct StmSpiState *state = &pdev->state;
if (pdev->board->sleepDev >= 0)
platReleaseDevInSleepMode(pdev->board->sleepDev);
while (regs->SR & SPI_SR_BSY)
;
if (stmSpiIsMaster(pdev)) {
if (state->nssChange && pdev->nss)
gpioSet(pdev->nss, 1);
spiMasterRxTxDone(pdev->base, err);
} else {
regs->CR2 = SPI_CR2_TXEIE;
spiSlaveRxTxDone(pdev->base, err);
}
}
void bringUpChip(){
#ifndef NOIO
output(1,"Bringing up GPIOs 53,71 and 124\n");
gpioSet(53,1);
gpioSet(71,1);
gpioSet(124,1);
usleep(5000); //at least 5ms sleep
output(1,"Twiddeling GPIO 114\n");
gpioSet(114,1); //raise 114
usleep(3000); //wait 3ms
gpioSet(114,0); //drop it again
usleep(3000); //wait 3ms
output(1,"Bringing up GPIOs 81 and 114\n");
gpioSet(81,1); //raise 81 and 114
gpioSet(114,1);
usleep(500000); //wait 500ms
#endif
}
static int stmSpiRxTx(struct SpiDevice *dev, void *rxBuf, const void *txBuf,
size_t size, const struct SpiMode *mode)
{
struct StmSpiDev *pdev = dev->pdata;
struct StmSpi *regs = pdev->cfg->regs;
struct StmSpiState *state = &pdev->state;
bool rxMinc = true, txMinc = true;
uint32_t cr2 = SPI_CR2_TXDMAEN;
if (atomicXchgByte(&state->xferEnable, true) == true)
return -EBUSY;
if (stmSpiIsMaster(pdev) && pdev->nss)
gpioSet(pdev->nss, 0);
state->rxDone = false;
state->txDone = false;
state->nssChange = mode->nssChange;
/* In master mode, if RX is ignored at any point, then turning it on
* later may cause the SPI/DMA controllers to "receive" a stale byte
* sitting in a FIFO somewhere (even when their respective registers say
* their FIFOs are empty, and even if the SPI FIFO is explicitly cleared).
* Work around this by DMAing bytes we don't care about into a throwaway
* 1-word buffer.
*
* In slave mode, this specific WAR sometimes causes bigger problems
* (the first byte TXed is sometimes dropped or corrupted). Slave mode
* has its own WARs below.
*/
if (!rxBuf && stmSpiIsMaster(pdev)) {
rxBuf = &state->rxWord;
rxMinc = false;
}
if (rxBuf) {
stmSpiStartDma(pdev, &pdev->board->dmaRx, rxBuf, mode->bitsPerWord,
rxMinc, size, stmSpiRxDone, true);
cr2 |= SPI_CR2_RXDMAEN;
} else {
state->rxDone = true;
}
if (!txBuf) {
txBuf = &state->txWord;
txMinc = false;
}
stmSpiStartDma(pdev, &pdev->board->dmaTx, txBuf, mode->bitsPerWord, txMinc,
size, stmSpiTxDone, false);
/* Ensure the TXE and RXNE bits are cleared; otherwise the DMA controller
* may "receive" the byte sitting in the SPI controller's FIFO right now,
* or drop/corrupt the first TX byte. Timing is crucial here, so do it
* right before enabling DMA.
*/
if (!stmSpiIsMaster(pdev)) {
regs->CR2 &= ~SPI_CR2_TXEIE;
NVIC_ClearPendingIRQ(pdev->cfg->irq);
if (regs->SR & SPI_SR_RXNE)
(void)regs->DR;
if (regs->SR & SPI_SR_TXE)
regs->DR = mode->txWord;
}
if (pdev->board->sleepDev >= 0)
platRequestDevInSleepMode(pdev->board->sleepDev, 12);
regs->CR2 = cr2;
regs->CR1 |= SPI_CR1_SPE;
return 0;
}
int main(int argc, char **argv){
int i,j;
int gpio[128];
int oldstate[128], state[128];
int ngpios;
struct timeval tv;
fd_set read_fd;
char *str = NULL;
int lenStr = 0;
ngpios = argc - 1;
for(i=0;i<128;i++)
gpio[i] = -1;
for(i=0;i<ngpios;i++){
j = atoi(argv[i+1]);
gpio[i] = j;
oldstate[i] = -1;
}
#ifndef NOIO
gpioInit();
#endif
do{
tv.tv_sec=0;
tv.tv_usec=1000;
FD_ZERO(&read_fd);
FD_SET(0,&read_fd);
if(select(1, &read_fd,NULL,NULL,&tv) == -1)
return 0;
if(FD_ISSET(0,&read_fd)){
getline(&str, &lenStr, stdin);
i=strlen(str);
if(str[i-1] =='\n')
str[i-1] = 0x00;
if(str == NULL)
break;
if(str[0] == 'q')
break;
else if(str[0] == 'o'){
printf("GPIO #:");
getline(&str, &lenStr, stdin);
i=atoi(str);
#ifndef NOIO
if(i >=0 && i < 128)
gpioSetDir(i, 1);
#endif
printf("%i --> output\n",i);
}else if(str[0] == 'i'){
printf("GPIO #:");
getline(&str, &lenStr, stdin);
i=atoi(str);
#ifndef NOIO
if(i >=0 && i < 128)
gpioSetDir(i, 0);
#endif
printf("%i --> input\n",i);
}else if( str[0] >= '0' && str[0] <='9'){ //toggle
i = atoi(str);
if(i >=0 && i < 128){
#ifndef NOIO
j = gpioGet(i);
printf("%i: %i --> %i\n",i,j,!j);
gpioSet(i, !j);
#endif
}
}
}
for(i=0;i<ngpios;i++){
#ifdef NOIO
state[i] = 0;
#else
state[i] = gpioGet( gpio[i] );
#endif
if( state[i] != oldstate[i] )
printf("%i: %i --> %i\n",gpio[i],oldstate[i],state[i]);
oldstate[i] = state[i];
}
}while(1);
#ifndef NOIO
gpioCleanup();
#endif
if(str != NULL)
free(str);
return 0;
}
/*******************************************************************************
*
* initFetPreDriver
*
* Reset and initialize the Freescale 33937A FET Pre-driver chip
*
*
******************************************************************************/
static int initFetPreDriver(int timer, int spiFd)
{
int retVal = !ERROR;
uint8_t cmd[8];
spiWriteRead_t spiTxRx = {
.out = cmd,
.in = cmd,
.len = 1,
};
int i;
printf("Initializing FET pre driver...\n");
/* Put the chip into reset and disable */
gpioClear(FET_DRIVER_RESET_PORT, FET_DRIVER_RESET_PIN);
gpioClear(FET_DRIVER_ENABLE_PORT, FET_DRIVER_ENABLE_PIN);
taskDelay(100);
/* Take chip out of reset and wait for VDD and VLS to stabilize */
gpioSet(FET_DRIVER_RESET_PORT, FET_DRIVER_RESET_PIN);
taskDelay(50);
/* Clear interrupt status flags */
cmd[0] = CLINT0_CMD | 0xf;
ioctl(spiFd, IO_IOCTL_SPI_WRITE_READ, (int) &spiTxRx);
cmd[0] = CLINT1_CMD | 0xf;
ioctl(spiFd, IO_IOCTL_SPI_WRITE_READ, (int) &spiTxRx);
/* Subscribe to interrupt sources */
cmd[0] = MASK0_CMD | MASK0_OVERTEMP_BIT | MASK0_OVER_CURRENT_BIT
| MASK0_VLS_UNDER_VOLTAGE_BIT ;
ioctl(spiFd, IO_IOCTL_SPI_WRITE_READ, (int) &spiTxRx);
cmd[0] = MASK1_CMD | MASK1_FRAMING_ERROR_BIT
| MASK1_WRITE_ERROR_BIT | MASK1_RESET_EVENT_BIT;
ioctl(spiFd, IO_IOCTL_SPI_WRITE_READ, (int) &spiTxRx);
#if 1
/* Use zero deadtime at pre driver (ftm uses deadtime already) */
cmd[0] = DEADTIME_CMD;
printf("read %d \n", ioctl(spiFd, IO_IOCTL_SPI_WRITE_READ, (int) &spiTxRx));
printf("deadtime returned %x \n", cmd[0]);
#endif
/* Using default deadtime. Otherwise set it here. */
#if 0
/* TODO Test this */
cmd[0] = DEADTIME_CMD | DEADTIME_CALIBRATE_BIT;
write(spiFd, cmd, 1);
taskDelay(10);
read(spiFd, cmd, 1);
ioctl(spiFd, IO_IOCTL_SPI_SET_OPTS, SPI_OPTS_MASTER | SPI_OPTS_PCS_CONT);
taskDelay(PERIOD_16_TIMES_LONGER_THAN_DESIRED_DEADTIME);
ioctl(spiFd, IO_IOCTL_SPI_SET_OPTS, SPI_OPTS_MASTER);
#endif
/* Setup any special mode settings and lock mode */
cmd[0] = MODE_CMD | MODE_FULLON_BIT | MODE_DESATURATION_FAULT_BIT;
//cmd[0] = MODE_CMD | MODE_DESATURATION_FAULT_BIT;
//| MODE_MODE_LOCK_BIT;
ioctl(spiFd, IO_IOCTL_SPI_WRITE_READ, (int) &spiTxRx);
/* Bring up the enable lines (they are tied together in this design)
* and get ready for some f#cking smoke! :) */
gpioSet(FET_DRIVER_ENABLE_PORT, FET_DRIVER_ENABLE_PIN);
cmd[0] = NULL_CMD | 0;
write(spiFd, cmd, 1);
taskDelay(50);
/* Check status for fun */
for (i = 0; i < MAX_NULL_CMD_REG; i++) {
cmd[0] = NULL_CMD | i;
write(spiFd, cmd, 1);
taskDelay(50);
read(spiFd, cmd, 1);
// if (i) {
if (i==0) {
cmd[0] &= ~STATUS_REG0_RESET_EVENT;
if (cmd[0]) {
retVal = ERROR;
}
}
printf("FET Pre Amp Status[%d] %x\n", i, cmd[0]);
// }
}
// read(spiFd, cmd, 1);
// printf("FET Pre Amp Status[%d] %x\n", i, cmd[0]);
taskDelay(50);
if (retVal != ERROR) {
/* Turn on all low sides */
ftmSetOutputMask(FTM_0, MASK_HIGH_SIDE, TRUE);
taskDelay(50);
/* Turn off all low sides */
ftmSetOutputMask(FTM_0, MASK_ALL_OUTPUTS, TRUE);
taskDelay(50);
/* Turn on all high sides */
ftmSetOutputMask(FTM_0, MASK_LOW_SIDE, TRUE);
taskDelay(1000);
/* Turn off all high sides */
ftmSetOutputMask(FTM_0, MASK_ALL_OUTPUTS, TRUE);
/* Good to go! */
printf("FET predriver initialized. \n");
#if 0
if (gpioRead(HALL_A_PORT, HALL_A_PIN)) {
value |= HALL_A_BIT;
}
if (gpioRead(HALL_B_PORT, HALL_B_PIN)) {
value |= HALL_B_BIT;
}
if (gpioRead(HALL_C_PORT, HALL_C_PIN)) {
value |= HALL_C_BIT;
}
if (value > 0 && value <= MAX_HALL_PHASE) {
int idx;
commutator.ready = TRUE;
commutator.hallPosition = value;
idx = commutationStepFromHallPos[commutator.hallPosition];
idx = 2;
// ftmSetOutputMask(FTM_0, commutator.commutationMask[idx], FALSE);
// ftmSetInvCtrl(FTM_0, commutator.bipolarCompliment[idx], TRUE);
} else {
/* Motor Position Fault! */
printf("Motor Position Fault! %d \n", value);
gpioClear(FET_DRIVER_ENABLE_PORT, FET_DRIVER_ENABLE_PIN);
gpioClear(FET_DRIVER_RESET_PORT, FET_DRIVER_RESET_PIN);
updateFlags |= UPDATE_HALT;
}
#endif
} else {
printf("Fault on FET PreDriver! \n");
// gpioClear(FET_DRIVER_ENABLE_PORT, FET_DRIVER_ENABLE_PIN);
// gpioClear(FET_DRIVER_RESET_PORT, FET_DRIVER_RESET_PIN);
// updateFlags |= UPDATE_HALT;
}
return retVal;
}
static void setClock(void)
{
/* -------- 100 MHz (external clock) -----------
* Configure the Multipurpose Clock Generator output to use the external
* clock locked with a PLL at the maximum frequency of 100MHZ
*
* For PLL, the dividers must be set first.
*
* System: 100 MHz
* Bus: 50 MHz
* Flexbus: 25 MHz
* Flash: 25 MHz
*/
clockSetDividers(DIVIDE_BY_1, DIVIDE_BY_2, DIVIDE_BY_4, DIVIDE_BY_4);
clockConfigMcgOut(MCG_PLL_EXTERNAL_100MHZ);
return;
}
static svm_t resolveSVM(scaled_t output, scaled_t angle)
{
svm_t svm;
scaled_t relativeAngle[2];
scaled_t duty[3]; /* [duty_1, duty_2, half duty_0] */
angle %= 360 * UNITY;
if (angle <= SVM_VECTOR_60) {
gpioSet(N_LED_BLUE_PORT, N_LED_BLUE_PIN);
gpioSet(N_LED_GREEN_PORT, N_LED_GREEN_PIN);
gpioSet(N_LED_YELLOW_PORT, N_LED_YELLOW_PIN);
relativeAngle[1] = angle;
relativeAngle[0] = SVM_60_DEGREES - relativeAngle[1];
svm.sinLUTIdx = svmDuty(duty, relativeAngle, output);
svm.pwmADuty = duty[0] + duty[1] + duty[2];
svm.pwmBDuty = duty[1] + duty[2];
svm.pwmCDuty = duty[2];
} else if (angle <= SVM_VECTOR_120) {
gpioSet(N_LED_BLUE_PORT, N_LED_BLUE_PIN);
gpioSet(N_LED_GREEN_PORT, N_LED_GREEN_PIN);
gpioClear(N_LED_YELLOW_PORT, N_LED_YELLOW_PIN);
relativeAngle[1] = angle - SVM_VECTOR_60;
relativeAngle[0] = SVM_60_DEGREES - relativeAngle[1];
svm.sinLUTIdx = svmDuty(duty, relativeAngle, output);
svm.pwmADuty = duty[0] + duty[2];
svm.pwmBDuty = duty[0] + duty[1] + duty[2];
svm.pwmCDuty = duty[2];
} else if (angle <= SVM_VECTOR_180) {
gpioSet(N_LED_BLUE_PORT, N_LED_BLUE_PIN);
gpioClear(N_LED_GREEN_PORT, N_LED_GREEN_PIN);
gpioSet(N_LED_YELLOW_PORT, N_LED_YELLOW_PIN);
relativeAngle[1] = angle - SVM_VECTOR_120;
relativeAngle[0] = SVM_60_DEGREES - relativeAngle[1];
svm.sinLUTIdx = svmDuty(duty, relativeAngle, output);
svm.pwmADuty = duty[2];
svm.pwmBDuty = duty[0] + duty[1] + duty[2];
svm.pwmCDuty = duty[1] + duty[2];
} else if (angle < SVM_VECTOR_240) {
gpioSet(N_LED_BLUE_PORT, N_LED_BLUE_PIN);
gpioClear(N_LED_GREEN_PORT, N_LED_GREEN_PIN);
gpioClear(N_LED_YELLOW_PORT, N_LED_YELLOW_PIN);
relativeAngle[1] = angle - SVM_VECTOR_180;
relativeAngle[0] = SVM_60_DEGREES - relativeAngle[1];
svm.sinLUTIdx = svmDuty(duty, relativeAngle, output);
svm.pwmADuty = duty[2];
svm.pwmBDuty = duty[0] + duty[2];
svm.pwmCDuty = duty[0] + duty[1] + duty[2];
} else if (angle < SVM_VECTOR_300) {
gpioClear(N_LED_BLUE_PORT, N_LED_BLUE_PIN);
gpioSet(N_LED_GREEN_PORT, N_LED_GREEN_PIN);
gpioSet(N_LED_YELLOW_PORT, N_LED_YELLOW_PIN);
relativeAngle[1] = angle - SVM_VECTOR_240;
relativeAngle[0] = SVM_60_DEGREES - relativeAngle[1];
svm.sinLUTIdx = svmDuty(duty, relativeAngle, output);
svm.pwmADuty = duty[1] + duty[2];
svm.pwmBDuty = duty[2];
svm.pwmCDuty = duty[0] + duty[1] + duty[2];
} else {
gpioClear(N_LED_BLUE_PORT, N_LED_BLUE_PIN);
gpioSet(N_LED_GREEN_PORT, N_LED_GREEN_PIN);
gpioClear(N_LED_YELLOW_PORT, N_LED_YELLOW_PIN);
relativeAngle[1] = angle - SVM_VECTOR_300;
relativeAngle[0] = SVM_60_DEGREES - relativeAngle[1];
svm.sinLUTIdx = svmDuty(duty, relativeAngle, output);
svm.pwmADuty = duty[0] + duty[1] + duty[2];
svm.pwmBDuty = duty[2];
svm.pwmCDuty = duty[0] + duty[2];
}
return svm;
}
void performCommandPLC()
{
UINT8 ui8NameStrDL[15];
UINT32 pos;
UINT32 err = SUCCESS;
UINT32 ui32dstDirPos;
switch(ucHMI_addr)
{
case PLC_TIME:
stime.tm_sec = uiHMIWord[PLC_TIME+5];
stime.tm_min = uiHMIWord[PLC_TIME+4];
stime.tm_hour = uiHMIWord[PLC_TIME+3];
stime.tm_mday = uiHMIWord[PLC_TIME+2];
stime.tm_mon = uiHMIWord[PLC_TIME+1];
stime.tm_year = uiHMIWord[PLC_TIME]-1900;
timeSet(&stime);
#if C_LEVI_DEBUG
printf("time=%d/%d/%d %d:%d:%d ",uiHMIWord[PLC_TIME],uiHMIWord[PLC_TIME+1],uiHMIWord[PLC_TIME+2],uiHMIWord[PLC_TIME+3],uiHMIWord[PLC_TIME+4],uiHMIWord[PLC_TIME+5]);
#endif
if((uiHMIWord[PLC_TIME]!=2000)||(uiHMIWord[PLC_TIME+1]!=01))
ui8TimeFlag = 1;
timeGet(&ptime);
sio_psprintf(ui8NameStrDL, "%02d%02d%02dDC.CSV", (UINT32)(ptime->tm_year-100)%100, ptime->tm_mon,ptime->tm_mday);
xdcfCurRootDirSet(ui8TermModule);
//mp3_GetFileList();
pos = myFindFile(ui8NameStrDL);
myGetSingleDayDL(pos, &ui32SuccessNum);
break;
case PLC_PARA_BUF:
memcpy((UINT8 *)&curDevice, (UINT8 *)&uiHMIWord[PLC_PARA_BUF], C_PLC_PARA_NUM*sizeof(UINT16));
#if C_LEVI_DEBUG
printf("device=%d, class=%d ",uiHMIWord[PLC_MODULE_NO],uiHMIWord[PLC_MODULE_NO+1]);
#endif
getModuleName(ui16CurModule, ui8TermModule);
writePara();
//readPara();
break;
case PLC_MODULE_NO:
#if C_LEVI_DEBUG
printf("device=%d, class=%d ",uiHMIWord[PLC_MODULE_NO],uiHMIWord[PLC_MODULE_NO+1]);
#endif
ui16CurModule = uiHMIWord[PLC_MODULE_NO];
ui16CurClass = uiHMIWord[PLC_MODULE_NO+1];
getModuleName(ui16CurModule, ui8TermModule);
readPara();
writePara();
readParadelaytime();
writeParadelaytime();
break;
case TESTSTEP0:
test_step0=(~uiHMIWord[TESTSTEP0])&0xffff;
test_step1=(~uiHMIWord[TESTSTEP1])&0xff;
test_mode=(uiHMIWord[TestMode]&0x01);
printf("test_step0=%d, test_step1=%d, test_mode=%d ",test_step0,test_step1,test_mode);
break;
case delay_time:
memcpy((UINT8 *)&delay,(UINT8 *)&uiHMIWord[delay_time],C_delay_NUM*sizeof(UINT16));
//memcpy((UINT8 *)&uiHMIWord[delay_time], (UINT8 *)&delay, C_delay_NUM*sizeof(UINT16));
getModuleName(ui16CurModule, ui8TermModule);
writeParadelaytime();
//readParadelaytime();
break;
case PLC_BAKCMD:
gpioConfig(GPIO_CARD_DET, 0);
gpioSet(GPIO_CARD_DET, 1);
if(gpioGet(GPIO_CARD_DET)==0)
{
err = xdcfActiveDevIdSet(DRIVE_SD);
xdcfInit(imageDirNameStr, imageFileNameStr, 0);
dirInit();
if(err==SUCCESS)
{
xdcfChange2Root();
vfsMkdir(ui8TermModule);
xdcfCurRootDirSet(ui8TermModule);
xdcfCurDirPosGet(&ui32dstDirPos);
myXdcfDelFile();
xdcfActiveDevIdSet(DRIVE_NAND);
xdcfCurRootDirSet(ui8TermModule);
xdcfChange2Root();
vfsChdir(ui8TermModule);
err |= myXdcfCopyDisk(ui32dstDirPos);
if(uiHMIWord[PLC_BAKCMD])
{
myXdcfDelFile();
}
if(err==SUCCESS)
uiHMIWord[PLC_BAKINFO] = 2;
else
uiHMIWord[PLC_BAKINFO] = 4; // ¶ÁSD¿¨´íÎó
}
else
{
uiHMIWord[PLC_BAKINFO] = 4; // ¶ÁSD¿¨´íÎó
}
}
else
{
uiHMIWord[PLC_BAKINFO] = 3; // ûÓÐSD¿¨
}
#if C_FILE_DEBUG
printf("backup end ");
#endif
break;
default:
break;
}
}
void pbEBookShow(UINT8 flag, UINT32 ui32FileIdx )
{
UINT8 i, j;
UINT32 err = SUCCESS;
UINT32 pPBAddr, phyOsdDBAddr;
UINT32 tempIdx = 1;
UINT32 dispW, dispH;
UINT32 pbThumbW, pbThumbH, pbThumbOffX, pbThumbOffY;
pbThumbW = 120 ; // 160-40;
pbThumbH = 84 ; //120-36;
pbThumbOffX =150+20+2 ;
pbThumbOffY = 44+14+14;
//pImageBuf = (UINT8*) (((UINT32 )ui8EBookBuf) | 0xac000000);
//phyOsdDBAddr = (((UINT32)pEBookBuf) & 0x00FFFFFF) >> 1;
hwDateFontScalerSet(1);
pbThumbBufferGet(&pPBAddr);
hwDispPreviewSizeGet(&dispW, &dispH);
hwPlayBufSizeSet(dispW, dispH);
hwPlayBufAddrSet(ui32gPB);
if( flag == EBOOK_DRAW_PREVIEW )
{
err = xdcfFileTypeGet(ui32FileIdx, &ui32Filetype);
}
else if (flag == EBOOK_DRAW_BOOKTEXT)
{
pbDramImgPlay(MenupEBook[EBOOKREAD][0], MenupEBook[EBOOKREAD][1], ui32gPB, dispW, dispH);
osdClearScreen(0);
pbEBookTextGet();
if ( (TVFlag == 1 ) && (PANEL_TYPE_1 != getCurPanel()) )
{
gpioSet(GPIO_LCD_POWER, 1);
hwWait(0,300);
panelSelect(PANEL_TYPE_1);
sPara.TvoutFlag=TVOutOff;
TVFlag=0;
hwDispPvSetRead(imgBuf);
// ChgPvSetting = 1;
}
}
else if ( flag == EBOOK_DRAW_BG )
{
pbMainBack();
if (ui32FileCnt == 0)
{
#if 0 // tzw add
hwImgCopyDo((UINT32)pPBAddr, pbThumbW, pbThumbH, 0, 0, pbThumbW, pbThumbH,
ui32gPB, dispW, dispH,pbThumbOffX,pbThumbOffY, 0);
#endif
}
else
{
pbImagePaste( MenupEBook[EBOOKPICT][0], MenupEBook[EBOOKPICT][1], MenupEBook[EBOOKPICT][2], MenupEBook[EBOOKPICT][3] );
}
}
}
