[color=#000000]Tässä meiläläisen väsäämä köödi RSK7086:lle. Vaatii vielä hienosäätöä - mutta perusaisat ovat jo kohdallaan. Saa kommentoida.
/***********************************************************************************
FILE NAME : main.c
Trial code to read flash rom contents using AUD connector using Renesas RSK 7086
experimental board.
Concept based on code from Marlin Bially and MarkW
***********************************************************************************/
/**********************************************************************************
User Includes
***********************************************************************************/
/* Following header file provides a structure to access on-chip I/O registers. */
#include "iodefine.h"
/* Following header file provides common defines for widely used items. */
#include "rsk7086def.h"
/* Following header file provides prototypes for LCD controlling functions */
#include "lcd.h"
/* Following header file provides prototypes for timer & ADC controlling functions */
#include "timeradc.h"
/* Following header file provides prototype for functions contained in this file. */
#include "main.h"
/**********************************************************************************
Global constants
***********************************************************************************/
#define AUDDATA0 0x1
#define AUDDATA1 0x2
#define AUDDATA2 0x4
#define AUDDATA3 0x8
#define DIR 0x40 //PB6 direction line; write low
#define AUDCK 0x20 //PB5 clock
#define AUDSYNC 0x10 //PB4 Sync active low
#define READLONGW 0x08 //for read AUD line command %1000
#define READBYTE 0x0A //for read AUD line command %1010
#define PBCLKCYCLE 200 // constant for wait function
/*
THESE ARE THE DEFINITIONS FOR HARDWARE CONNECTIVITY on PORT D
PD_0 D0 J3-28 JA3-17 D0
PD_1 D1 J3-27 JA3-18 D1
PD_2 D2/TIC5U J3-26 JA3-19 D2
PD_3 D3/TIC5V J3-25 JA3-20 D3
PD_4 D4/TIC5W J3-24 JA3-21 D4
PD_5 D5/TIC5US J3-23 JA3-22 D5
*/
#define PD_AUDDATA0 PD.DR.BIT.B0
#define PD_AUDDATA1 PD.DR.BIT.B1
#define PD_AUDDATA2 PD.DR.BIT.B2
#define PD_AUDDATA3 PD.DR.BIT.B3
#define PD_AUDSYNC PD.DR.BIT.B4
#define PD_AUDCK PD.DR.BIT.B5
/**********************************************************************************
Global variables
***********************************************************************************/
volatile unsigned char gucKeyPressed = 0x00; // will be updated when key is pressed
/**********************************************************************************
User Program Code
***********************************************************************************/
void PBinitialize(void) //subroutine that sets the PBlines etc
{
PFC.PDIORL.BIT.B0 = 1; // configure as output
PFC.PDIORL.BIT.B1 = 1; // configure as output
PFC.PDIORL.BIT.B2 = 1; // configure as output
PFC.PDIORL.BIT.B3 = 1; // configure as output
PFC.PDIORL.BIT.B4 = 1; // configure as output
PFC.PDIORL.BIT.B5 = 1; // configure as output
LED0=LED_OFF;
LED1=LED_OFF;
LED2=LED_OFF;
LED3=LED_OFF;
}
void PBSetOutput(void) //subroutine that sets the PBlines for input
{
PFC.PDIORL.BIT.B0 = 1; // configure as output
PFC.PDIORL.BIT.B1 = 1; // configure as output
PFC.PDIORL.BIT.B2 = 1; // configure as output
PFC.PDIORL.BIT.B3 = 1; // configure as output
LED0=LED_ON;
}
void PBsetInput(void) //subroutine that sets the PBlines for input
{
PFC.PDIORL.BIT.B0 = 0; // configure as input
PFC.PDIORL.BIT.B1 = 0; // configure as input
PFC.PDIORL.BIT.B2 = 0; // configure as input
PFC.PDIORL.BIT.B3 = 0; // configure as input
LED1=LED_ON;
}
void PBwrite(unsigned int PBtemp) // function that sets all the PB lines for output
{
PD_AUDDATA0 = PBtemp & AUDDATA0;
PD_AUDDATA1 = PBtemp & AUDDATA1;
PD_AUDDATA2 = PBtemp & AUDDATA2;
PD_AUDDATA3 = PBtemp & AUDDATA3;
PD_AUDSYNC = PBtemp & AUDSYNC;
PD_AUDCK = PBtemp & AUDCK;
if (PBtemp & AUDCK)
LED3=LED_ON;
else
LED3=LED_OFF;
}
unsigned long PBread(void) // function that sets the [3:0] PB lines for reading
{
return((PD_AUDDATA0*AUDDATA0) + (PD_AUDDATA1*AUDDATA1) + (PD_AUDDATA2*AUDDATA2) + (PD_AUDDATA3*AUDDATA3));
}
wait(int i) // Function that is used for generating clock pulse for AUD
{
int n=0;
LED1=LED_ON;
for(n=0;n<PBCLKCYCLE*i;n++);
LED1=LED_OFF;
}
char *IntToStr (unsigned int an_integer) // integer to string for LCD display
{
volatile static char result [] = " "; // 10 spaces and \0
volatile char *ptr = result + 10;
int n=0;
int i=0;
// NOTE FUNCTION NOT TESTED PROPERLY, MAY NOT YIELD CORRECT ANSWERS
while (an_integer)
{
*ptr-- = an_integer % 10 + '0';
an_integer/=10;
}
*ptr++;
for (i=n;i<8;i++)*ptr--='0'; // fill in the rest with zeros
return ptr;
}
char *IntToHexStr(unsigned int an_integer)
{
volatile char const letters[]="0123456789ABCDEF" ;
volatile static char result[]= "00000000";
volatile char *ptr = result+7;
int n = 0;
int i = 0;
while (an_integer) // convert any 16bit hex to a hex char
{
*ptr--=letters[(an_integer % 16)];
an_integer/=16;
n++;
}
for (i=n;i<8;i++)*ptr--=letters[0]; // fill in the rest with zeros
return &result;
}
unsigned int GetAUDData(unsigned int MemAddr) // Get data from the MemAddr
{
volatile unsigned int n=0;
volatile unsigned int result = 0;
PBinitialize(); //routine that sets PB0 lines to default state
wait(5);
PBSetOutput(); //routine that sets PB0:3 to output
wait(5);
PBwrite(0); //all control, data low
wait(1); //wait half cycle
PBwrite(AUDCK); // set clock hi, cpu reads on rising edge %00100000
wait(1);
PBwrite(READLONGW); //write DIR i.e. AUD direction byte READLONGWORD or READBYTE
wait(1); //wait half cycle
PBwrite(AUDCK); // set clock hi, cpu reads on rising edge
wait(1);
for(n=0;n<8;n++) // process total 32 bits, 4 bits at a time
{
PBwrite(MemAddr & 0x0000000F); // out A[3:0], controls all low
wait(1);
PBwrite(AUDCK);
MemAddr = MemAddr / 16; // set clock hi, cpu reads on rising edge %00100000
wait(1); // This was not included on markw:s code
}
PBsetInput(); //routine that sets PB0:3 from outputs to inputs
PBwrite(DIR); //change the direction signal to read
wait(1);
PBwrite(DIR + AUDCK);
wait(1);
n=0;
while(!(PBread() & 1)) //loop until cpu sends ready byte %0001
{
PBwrite(DIR);
wait(1);
PBwrite(DIR + AUDCK);
wait(1);
if (n++>PBCLKCYCLE) // in case the CPU never sends a ready byte, show on LCD
{
DisplayString(LCD_LINE1,"TIMEOUT "); // convert and display second line on LCD
break; // just break from the loop if timeout
}
}
PBwrite(DIR + AUDSYNC); //set sync
wait(1);
PBwrite(DIR + AUDSYNC + AUDCK);
wait(1);
PBwrite(DIR + AUDSYNC); // set clock low
result = 0;
n=0;
for(n=0;n<8;n++) //read out 8 4bit nibbles of data requested
{
wait(1);
PBwrite(DIR + AUDSYNC + AUDCK); // cpu latches data out
wait(1); // give it time to settle
result *= 16; // shift result left to make room for new bits
result += PBread() & 0x0F; // add bits to result
PBwrite(DIR + AUDSYNC); // clock low
}
wait(1);
return(result);
}
/***********************************************************************************
Function Name : main
Description : Main function.
Parameters : none
Return value : none
***********************************************************************************/
void main(void)
{
volatile unsigned int tmpaddr;
InitialiseDisplay(); // reset the LCD module
DisplayString(LCD_LINE1,"AUDdebug"); // write first line on LCD
// TimerADC(); // not to be used
tmpaddr=0xFFAB0111; // just testing with one address, a loop and writing to SIO will be added
DisplayString(LCD_LINE1,IntToHexStr(tmpaddr)); // convert and display on LCD
DisplayString(LCD_LINE2,IntToHexStr(GetAUDData(tmpaddr))); // convert and display second line on LCD
/* End of user program. This function must not exit. */
while(1);
}
/***********************************************************************************
End of function main
***********************************************************************************/
/***********************************************************************************
End of file
***********************************************************************************/[/color]