busanistit.org

Lähetetty: **16 Marras 2007, 22:36**

Tässä mitä bozo lähetti. Tämä vaikuttaisi toimivan parallaxilla:

{
AUD PROBE
Mark Wrigley
NOVEMBER 2007

PA3 17 Nov 07
1. removed unused code
2. added full comments

PA2 16 Nov 07

1. corrected an error in the routine that sends address to AUDATA lines
it was rotating right temp1, but was sending Addr to AUDATA
correction sends temp1 to AUDATA

2. modified the wait loop that waits for a ready condition from the ECU
previous: loop 10 times
now: break out of loop after 10 loops or a ready/OK signal (%0001)

3. modified code after the wait loop to prevent trying to read AUDATA if
the wait loop executed 10 times ... program ends if this happens

4. eliminated SendLong ... send data to hyperterminal all contained in the main routine

5a.7052 datasheet specifies 5v for AUDRST and AUDMD. Since AUDMD is pulled high internally
if not connected, no need to set it. AUDRST interface should be o/p low to pull low,
and change to an input to let an external pullup resistor pull the line high to 5v.
Reset routine modified.

5b.A similar arrangement can be used for AUDMD if necessary. The datasheet says AUDMD will
be pulled high if unconnected, so probably no need to implement this?

6. Clock pulses are needed at RST/MD reset and mode setting, added at RAM_Mode

7. check AUD timing, clock should be high,low,high or low,high,low?
answer: high-low-high

8. modified clock pulse timing when reading back from the 7052

9. outputs from 7052 are 5v ... need to use say 1k resistors to limit current into propeller
on the AUDATA lines

}
CON

_clkmode = xtal1 + pll16x
_xinfreq = 5_000_000

'┌─────────────────────┐
'│ PIN ALLOCATIONS │
'└─────────────────────┘

pin_AUDRST = 7
pin_AUDMD = 6
pin_AUDATA0 = 5
pin_AUDATA1 = 4
pin_AUDATA2 = 3
pin_AUDATA3 = 2
pin_AUDSYNC = 1
pin_AUDCK = 0

clkrate = 10000

input = 0
output = 1

OBJ
Debug : "FullDuplexSerialPlus"

VAR
'┌─────────────────────┐
'│ COG STACKS ETC │
'└─────────────────────┘
long Stack1[19], Stack2[19], Stack3[9]
byte DebugCog

'┌─────────────────────┐
'│ VARIABLES │
'└─────────────────────┘
long Addr
long ReadBits
byte temp
byte i

PUB Main
DebugCog := Debug.start(31, 30, 0, 57600) 'start the serial comms
i := 0 'initialise i

dira[pin_AUDRST]~ 'RST pin is input (pulled high externally)
outa[pin_AUDRST] := 0 'RST will be pulled low when dira makes it an output

AUDATA(output) 'all AUDATA pins are output
dira[pin_AUDSYNC]~~ 'SYNC pin is output
dira[pin_AUDCK]~~ 'CK pin is output
outa[pin_AUDCK] := 1 'added PA2, set clock high
outa[pin_AUDSYNC] := 1 'pull SYNC line high

waitcnt(clkfreq*10+cnt) '10-sec delay to allow time to connect hyperterminal
'the USB is shared between IDE and hyperterminal

debug.str(String(13,10))
debug.str(String("Start...",13,10))

'set the starting address
Addr := 0

RAM_Mode 'AUD mode selection

repeat
ReadByte 'get byte from current Addr
Addr := Addr+1 'bump Addr
until Addr==0 or i==10 'do this until Addr reaches zero,
'or until hitting an error condition, whichever comes first

if i==10 'i.e. error
debug.str(String("error",13,10))
else 'i.e. no error
debug.str(String("done",13,10))

'END OF CODE EXECUTION

PUB RAM_Mode
dira[pin_AUDRST]~~ 'RST now an output
outa[pin_AUDRST] := 0 'RST pulled low
repeat 10
ClockPulse
dira[pin_AUDRST]~ 'restore RST to input, pulled high by external resistor
repeat 10 'these clocks probably not needed,
ClockPulse 'but I guess they can't hurt

PUB ReadByte | temp1, temp2
repeat 5 'probably only one clock pulse is needed here?
ClockPulse
outa[pin_AUDSYNC] := 0 'SYNC pulled low

' send 0000
outa[pin_AUDATA3] := 0
outa[pin_AUDATA2] := 0
outa[pin_AUDATA1] := 0
outa[pin_AUDATA0] := 0
ClockPulse

' send command to read byte (1000) ... read longword is 1010
outa[pin_AUDATA3] := 1
outa[pin_AUDATA2] := 0
outa[pin_AUDATA1] := 0
outa[pin_AUDATA0] := 0
ClockPulse

temp1 := Addr 'temp1 = next address to read
repeat 8 'send nibbles 8 times (total 32 bits)
outa[pin_AUDATA3..pin_AUDATA0] := temp1 'send 4 LSBs of address to AUDATA pins
ClockPulse 'clock them out
temp1 := temp1 >> 4 'rotate address right by 4 bits

AUDATA(input) 'prepare AUDATA lines as inputs

debug.str(String(13,10)) 'write address to hyperterminal
debug.hex(Addr,8)
debug.str(String(","))

'read in data until AUD is ready (0001)
i := 0
repeat
i++
temp := 0
ClockPulse
temp := ina[pin_AUDATA3..pin_AUDATA0] 'read in the data
until temp == %00000001 or i == 10

outa[pin_AUDSYNC] := 1 'SYNC pulled high

if i <> 10 'i.e. 7052 is ready and no errors
temp1 := 0
temp2 := 0
repeat 2 'read 4-bit nibbles from AUDATA lines
temp1 := temp1 << 4 'shift temp1 4 bits to the left
ClockPulse 'clock in the next set of AUDATA bits
temp2 := 0 'clear temp2
temp2 := ina[pin_AUDATA3..pin_AUDATA0] 'temp2 = received data from the ECU
temp1 := temp1 | temp2 'temp2 added on to the shifted temp1 value

ReadBits := temp1 'store result in ReadBits
debug.hex(ReadBits,8)
debug.str(String(","))

AUDATA(output) 'restore AUDATA pins to outputs

PUB ClockPulse
'send clock low then high
waitcnt(clkfreq/(clkrate/2) + cnt)
outa[pin_AUDCK] := 0
waitcnt(clkfreq/clkrate + cnt)
outa[pin_AUDCK] := 1
waitcnt(clkfreq/(clkrate/2) + cnt)

PUB AUDATA(direction)
if direction == input
dira[pin_AUDATA0]~
dira[pin_AUDATA1]~
dira[pin_AUDATA2]~
dira[pin_AUDATA3]~
if direction == output
dira[pin_AUDATA0]~~
dira[pin_AUDATA1]~~
dira[pin_AUDATA2]~~
dira[pin_AUDATA3]~~

Lähetetty: **18 Marras 2007, 00:31**

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
***********************************************************************************/

Lähetetty: **19 Marras 2007, 23:16**

Nyt oltais siinä vaiheessa, että PIC pohjainen lukulaite on tinattu kasaan ja testattu, porttien lukeminen ja kirjoitus ovat kunnossa, yhteys PC:lle kumpaankin suuntaan myös kunnossa ja PIC tuottaa Itsenäisesti ohjelman ohella kellopulssia ulos.

Vielä pitäis tehdä PC:lle ohjelma joka kirjoittaa ja lukee PIC:ä. PIC:n sisään meinasin ladata esimerkin mukaisen ohjelman, ja "yrittää" Flash:n lukemista sillä, purkkaa se on, mutta ainakin PicBasicLite Plus kääntäjästä se meni läpi. Viiveet pitää vielä myös tarkistella.

Tietysti jos joku osais vääntää asm:lla valmiin toimivan koodin, niin ei tarttis alkaa tuolla harjoittelemaan.

'' Määritellään PIC:n asetukset ja ohjelman käyttämät muuttujat ''

DEVICE 16F628
DECLARE XTAL 20
DECLARE CCP1.1 PORTB.3
DECLARE SERIAL_DATA 8
CONFIG WDT_OFF , HS_OSC , PWRTE_OFF,
SYMBOL AuData3 = PORTB.4
SYMBOL AuData2 = PORTB.7
SYMBOL AuData1 = PORTB.6
SYMBOL AuData0 = PORTB.5
SYMBOL Dir = PORTA.0
SYMBOL AudSync = PORTA.3
SYMBOL Audck_pin = PORTA.1
SYMBOL SerInput = PORTB.1
SYMBOL SerOutput = PORTB.2
Dim Write_Byte as byte '' Byte 8 bittinen muuttuja ''
Dim Read_Byte as byte
Dim AudData3_0 as byte
Dim AudData7_4 as byte
Dim AudData11_8 as byte
Dim AudData15_12 as byte
Dim AudData19_16 as byte
Dim AudData23_20 as byte
Dim AudData27_24 as byte
Dim AudData31_28 as byte
Dim x as byte

cmcon = 7 '' Pin.9 tuottamaan kellopulssia ulos 50% 1-0 suhteella ''
vrcon = 0
trisb = %00010000
pr2 = 100
ccp1con =% 00001100
t2con = %00000100
ccpr1l = 50

Input AuData3 '' portit input ''
Input AuData2
Input AuData1
Input AuData0
Input Audck
output dir '' portit output ''
output AudSync
high dir '' 74HC245 ylös''
high AudSync '' AudSync ylös ''

SerInput1:

Serin SerInput , 6 , [Write_Byte] '' Luetaan PC:ltä 38400,N,8,1 ''
if Write_Byte <> 75 then goto SerInput1 '' Odotetaan "K" kirjainta ASCII koodi 75 ''

FOR x = 1 to 8

Serin SerInput , 6 , [Write_Byte] '' Luetaan PC:ltä ASCII koodina muistiosoite tavu kerrallaan (PIC RxD puskuri 8 bittiä) ''

if Write_Byte = 48 then Write_Byte = 0 '' 0 ''
if Write_Byte = 49 then Write_Byte = 1 '' 1 ''
if Write_Byte = 50 then Write_Byte = 2 '' 2 ''
if Write_Byte = 51 then Write_Byte = 3 '' 3 ''
if Write_Byte = 52 then Write_Byte = 4 '' 4 ''
if Write_Byte = 53 then Write_Byte = 5 '' 5 ''
if Write_Byte = 54 then Write_Byte = 6 '' 6 ''
if Write_Byte = 55 then Write_Byte = 7 '' 7 ''
if Write_Byte = 56 then Write_Byte = 8 '' 8 ''
if Write_Byte = 57 then Write_Byte = 9 '' 9 ''
if Write_Byte = 65 then Write_Byte = 10 '' A ''
if Write_Byte = 66 then Write_Byte = 11 '' B ''
if Write_Byte = 67 then Write_Byte = 12 '' C ''
if Write_Byte = 68 then Write_Byte = 13 '' D ''
if Write_Byte = 69 then Write_Byte = 14 '' E ''
if Write_Byte = 70 then Write_Byte = 15 '' F ''

IF x = 1 then AudData3_0 = Write_Byte
IF x = 2 then AudData7_4 = Write_Byte
IF x = 3 then AudData11_8 = Write_Byte
IF x = 4 then AudData15_12 = Write_Byte
IF x = 5 then AudData19_16 = Write_Byte
IF x = 6 then AudData23_20 = Write_Byte
IF x = 7 then AudData27_24 = Write_Byte
IF x = 8 then AudData31_28 = Write_Byte

next

output AuData3 '' portit output ''
output AuData2
output AuData1
output AuData0

GOSUB Audck

LOW Dir '' 74HC245 alas''
LOW AudSync '' AudSync alas ''

LOW AuData3 '' dummy bitit ""
LOW AuData2
LOW AuData1
LOW AuData0

GOSUB Audck

HIGH AuData3 '' ilmoitus lukemisesta 32 bittisenä 1010''
LOW AuData2
HIGH AuData1
LOW AuData0

For x = 1 to 8 '' Haetaan osoitetavuista bitit ja kirjoitetaan ne AUDATA linjoihin neljän bitin sarjoissa jokaisella kellopulsilla''
if x = 1 then Write_Byte = AudData3_0
if x = 2 then Write_Byte = AudData7_4
if x = 3 then Write_Byte = AudData11_8
if x = 4 then Write_Byte = AudData15_12
if x = 5 then Write_Byte = AudData19_16
if x = 6 then Write_Byte = AudData23_20
if x = 7 then Write_Byte = AudData27_24
if x = 8 then Write_Byte = AudData31_28

gosub Audck

if Write_Byte & 8 = 8 then high AuData3 ' edit: korjattu
if Write_Byte & 8 = 0 then low AuData3
if Write_Byte & 4 = 4 then high AuData2
if Write_Byte & 4 = 0 then low AuData2
if Write_Byte & 2 = 2 then high AuData1
if Write_Byte & 2 = 0 then low AuData1
if Write_Byte & 1 = 1 then high AuData0
if Write_Byte & 1 = 0 then low AuData0

next

GOSUB Audck2

HIGH Dir '' 74HC245 ylös''

input AuData3 '' Portit input ''
input AuData2
input AuData1
input AuData0

No_Ready_Flag:
'' Odotetaan Ready Flag 0001 ''
GOSUB Audck

if AuData3 = 1 then goto No_Ready_Flag
if AuData2 = 1 then goto No_Ready_Flag
if AuData1 = 1 then goto No_Ready_Flag
if AuData0 = 0 then goto No_Ready_Flag

GOSUB Audck

HIGH AudSync '' AudSync ylös ''

For x = 1 to 8 '' Yhdistetään neljästä saapuvasta bitistä tavu ''

GOSUB Audck

Read_Byte = 0
Read_Byte = Read_Byte << 1
IF AuData3 = 1 THEN Read_Byte = Read_Byte + 1
Read_Byte = Read_Byte << 1
IF AuData2 = 1 THEN Read_Byte = Read_Byte + 1
Read_Byte = Read_Byte << 1
IF AuData1 = 1 THEN Read_Byte = Read_Byte + 1
Read_Byte = Read_Byte << 1
IF AuData0 = 1 THEN Read_Byte = Read_Byte + 1

serout SerOutput, 6, [#Read_Byte] '' tavun lähetys PC:lle 38400,N,8,1 ''

next

goto SerInput1

Audck: '' Haetaan kellopulssin alasmenon alkureunaa ''

Audck1:

If Audck_pin = 0 then goto Audck1

Audck2:

If Audck_pin = 1 then goto Audck2

RETURN
end

Edited By timo3 on 1195786148

Lähetetty: **21 Marras 2007, 21:10**

Jep,

Täälläkin on päästy kokeilumoodiin. AUD interface on valmis ja ohjelmaa testaillaan. Vähän on ollut ongelmia (mennyt kohta viikon illat asiaan) mutta tänään alkaa jo näyttämään siltä että lukeminen onnistuu, vaikka vielä onkin paljon lukuvirheitä.

Tässä alla linkki ohjelmaan jota käytän:
http://macmadigan.no-ip.com/Public/ECU/aud_pgm_draft3.txt

Ja lisäksi vielä interface joka tuli rakennettua verolevylle:

Jommassa kummassa on vielä vikaa, joko hw interfacessa pinnit kelluu tai sitten softassa on bugi - sillä muistin lukemisen tulokset aina vähän vaihtelevat lukukertojen välillä.

Lähetetty: **22 Marras 2007, 01:53**

Tuskimpa softassa pugia, mulla teki alussa ihan samaa, kun ei ollut alasvetovastuksia lukulinjoissa, kellu 0.7- 2.8 voltin välillä miten sattu milloinkin.

Lähetetty: **22 Marras 2007, 02:34**

timo3 kirjoitti:Tuskimpa softassa pugia, mulla teki alussa ihan samaa, kun ei ollut alasvetovastuksia lukulinjoissa, kellu 0.7- 2.8 voltin välillä miten sattu milloinkin.

ok - eli sulla on kanssa 74HC245 käytössä ?

Kummalle puolelle (ecu vai PIC) laitoit alasvetovastukset, mihin linjoihin ja minkä kokoisia käytit ? (10k, PIC puolella ?)

Ja tosiaankin käytit alasavetovastuksia eikä ylösvetovastuksia ?

Tässä alla kuva testiympäröstöstä sohvapöydällä:

Lähetetty: **22 Marras 2007, 15:24**

Juu, 74HC245 käytössä.
Tossa PIC:ssä kun määrää portit inputuksi, niin silloin ne portit lukiessa kelluu jos niitä ei vedä alas tai ylös.

Mitenkähän 7052:ssa on kun se kirjoittaa onko ne AuData:t lepotilassa 0 vai 5 volttia vai kelluu?
Onko ne esim, lepotilassa 5v ja ainakun se haluaa kirjoittaa nollan se vetää sen alas ja lun haluaa kirjoittaa 1:sen ei tee mitään. Sehän tietysti määräis kumpia siinä olis hyvä käyttää, alas vai ylösvetovastuksia.

PIC:ssä
Portit Output:ssa lepotilassa = 0
Portit Input:ssa lepotilassa = Kelluu
Sillä laitoin alasvetovastukset.

10k olis varmaan hyvä, ei vääristä pulssin nousu eikä laskuaikaa liikaa jos nopeus ei ole äärettömän suuri, eikä kuormita porttia, mulla ei ollut laatikossa kun 3.3k joten testailen nyt aluks niillä.

Miten tuo 74HC245 toimiiko se pelkkänä kytkimenä ja päästää pulssit läpi haluttuun suuntaan vai käyttääkö se oma jännitettä lähdöissä?

Ei muuten mikään äärettömän nopee lukulaite PIC:llä toteutettuna, kun PC:tä kirjoitetaan 32 bittin osoite ja sitten kun se vastaus on PC:ä luettavissa, ei tule kuin joku reilu kymmenkunta 32 bittistä lukua sekunissa. Johtuu tietysti osittain siitä kun joutuu kättelee ja myös päivitän näytölle kaikenlaista asiaa maan ja taivaan väliltä, tutkiessa ettei tulisi luku/kirjoitus virheitä PC:n ja PIC:n välillä.

Tuo sun pöytäshän näyttää siistiltä mun koeympäristöön nähden, heh...

Lähetetty: **22 Marras 2007, 19:59**

Jep - tuossa interface verolevyllä oli joku roska. Tein cutoutit dremelillä ja siitä tuleva pöly tuntuu aina aiheuttavan oikosulkuja. Vaikka katsoin levyä stereoloopeilla en löytänyt mitään, mutta mittaamalla näki että kahden liuskan välissä oli ylimääräinen kytkentä.

Nyt siis lukuohjelma toimii. Tässä linkki hyvin alustavaan mutta selvästi toimivaan koodiin jossa on vielä paljon myös debuggauskoodia mukana.
http://macmadigan.no-ip.com/Public/ECU/aud_pgm_working1.txt

Ja tässä verolevylle helposti kasattavissa oleva interface:

Ja tässä keskeytysvektoritaulusta pientä esimerkkiä Busan ecusta...

Renesas RSKSH7086 based AUD read program
00000000,00000000,00000400
00000001,00000004,FFFFAFAF
00000002,00000008,00000400
00000003,0000000C,FFFFAFAF
00000004,00000010,00022B20
00000005,00000014,00022B20
00000006,00000018,00022B20
00000007,0000001C,00022B20
00000008,00000020,00022B20
00000009,00000024,00022B20
0000000A,00000028,00022B20
0000000B,0000002C,00066210
0000000C,00000030,00099210
0000000D,00000034,00022B20
0000000E,00000038,00022B20
0000000F,0000003C,00022B20

Nyt ei muuta kuin kovaa koodaamista niin että saadaan koko koodi siirrettyä ja varmistettua että kaikki todella siirtyy asianmukaisesti.

Lähetetty: **23 Marras 2007, 10:19**

Toi sh7086 antaa kolmitasoisen outputin
High = Vcc
Low = Vss
Input = Z
Eli kun on inputtina niin samalla tavalla kelluu.

Toisaalta kun interface on tuo 74HC245 niin senhän pitäisi vetää signaalit ylös ja alas niin että kellumisen ei piäisi haitata. Mutta laitetaan tänään noi 10k vastukset sitten maadoittamaan tuo sh7086 puoli.

Testauksen mukaan ollaan melkein maalissa - mutta ei ihan vieläkään luotettavasti, mutta sitten huomasin tämän:

Olen ihmetellyt välillä että miksi datalinjoissa tulee -0.xxV potentiaalieroa - niin tässä taitaa olla selitys:

Input > Diodi > Vcc

Eli täytyy kokeilla laittaa myös sarjaan virtaa rajoittavat vastukset. Bozo oli käyttänyt muusta syystä 1k vastuksia (5v -> 3.3k konversio).

Lisäksi huomasin että tää mun ST micron sh74hc245B1 on 500ns tyyppiä kun vastaavasti alkuperäinen hitachin HDsh74245 piiri on 160ns. Olen yrittänyt huomoida tämän lisäämällä kellopulssin viivettä.

Aika lähellä ollaan tässä osa-alueessa...

Lähetetty: **23 Marras 2007, 13:07**

No niin,

Pulldown:t sekä 1uF tantaali Vcc Vss välille listätty ja alkoi pelittämään kohtuullisesti.

Täältä löytyy varmuuskopiot softista jotka sinne lisään aina sitä mukaa kun on jotain oleellista edistymistä.
http://macmadigan.no-ip.com/BusaECU....oftware

Tässä lisäksi loggaus Flas romin interrupt vektoritaulusta:
S3040000000000000400
S30400000004FFFFAFA0
S3040000000800000400
S3040000000CFFFFAFA0
S3040000001000002B20
S3040000001400002B20
S3040000001800002B20
S3040000001C00002B20
S3040000002000002B20
S3040000002400002B20
S3040000002800002B20
S3040000002C00001268
S3040000003000001296
S3040000003400002B20
S3040000003800002B20
S3040000003C00002B20
S50800000010

Ja tässä RAM alueen alusta:
S304FFFF000063408106
S304FFFF00042BE0B010
S304FFFF00088B010000
S304FFFF000C32338901
S304FFFF00100009B0E2
S304FFFF00140009E214
S304FFFF00182410000B
S304FFFF001C2410000B
S304FFFF002063402338
S304FFFF002400099068
S304FFFF00280009B04C
S304FFFF002C63408105
S304FFFF0030323309CD
S304FFFF003489030000
S304FFFF00388903E100
S304FFFF003C23201B36
S50800000010

Formaatiksi olen valinnut motorola S record tyypin. Noista yllä olevista puuttuu vielä tarkistussummat. Täytyy ensin selvittää miten se lasketaan ja lisätä kirjoitusfunktioon.

S-record on siinä mielessä hyvä että siinä on rivikohtainen checksum ja lopussa kerrotaan rivien määrä. Lisäksi FDT ohjelmointisofta osaa suoraan lukea s record dataa.

Netistä löytyy bit2mot ja mot2bin softat joilla tuo tiedostomuoto muuttuu s-recordin ja binäärin välillä.

Lähetetty: **23 Marras 2007, 14:27**

Aikonaan kun tein hekseditoria, muistaaksen INTEL HEX filessä rivien lopussa oleva tarkistus-summa laskettiin laskemalla kaikki rivillä olevat hex luvut yhteen ja vastauksesta vähennettiin aina niin kauan FF kunnes vastaus oli FF tai pienempi kuin FF ja se oli rivin loppuun tuleva tarkistesumma, sitten kaikki tarkistus-summat laskettiin yhteen ja tulos oli tiedoston lopussa oleva lopullinen tarkistesummana.

Huomasin tossa omassa jutussa omituisen ilmiön, jos luetaan 0 tai 5 volttia ja irroitetaan johto, niin se on silti lukiessa aina se sama niin kauan, ennen kuin sinne tulee uusi eri jännite tieto.

En tiedä tosta PIC:stä viekö se sen portin arvon muistiin ja lukiessa se muuta sitä muistin arvoa ennenkuin portin tila muuttuu toiseksi, noh täytyy tutkia.

Edited By timo3 on 1195823130

Lähetetty: **23 Marras 2007, 14:55**

Mullakin oli ongelmia noiden jännitelinjojen kanssa.Seuraavat asiat opittiin kantapään kautta:

- Lukunopeuden pitää olla riittävän suuri jotta lukeminen onnistuu
- Dremelilla tehdyt vero levyn linjojen katkaisut aiheuttivat kuparipölyä linjojen välissä ja siten oikosulkuja tai vastustarvoja joita ei ollut rakoitettu.
- 74hc245 tarvitsee nähtävästi sekä pulldown & tuon jännitelinjan tasoittavan konkan. Oma luki mitä sattuu vaikka piirin virrat eivät olleet päällä. Toinen kokeilu oli että laitoin yhden AUDDATA linjan pysyvästi Vcc:hen ja lukutulokset eivät pysyneet samoina.
- Siinä signaalikaavioissa ei näy selvästi tuon RST signaalin tarvetta. Mulla alkoi toimia kun RST singaali tuli lisättyä prosessointiin. main.c :stä näkee miten se toimii.

Tuo S-record checksum on jokaisen tavun summan negaatio. Luultavasti koodattuna jotain alla olevan kaltaista:

EDIT - Alle vaihdettu toimiva koodi:

S3record(unsigned int address, unsigned int data)
{
volatile int result=0;
volatile int counter;
volatile char *ptr_address;
volatile char *ptr_data;

// write the S3 recort to the com port
text_write("S309");

// write the 8 character address
ptr_address=IntToHexStr(address);
text_write(ptr_address);

// write the 8 character data
ptr_data=IntToHexStr(data);
text_write(ptr_data);

// calculate and write the checksum
result=9;
for (counter=0;counter<4;counter++) {
result+=(data&0xFF);
data>>=8;
}
for (counter=0;counter<4;counter++) {
result+=(address&0xFF);
address>>=8;
}
result&=0xFF;
result=~result;
text_write(IntToHexByte(result));

// next line
text_write("
");
}

S5record(unsigned int records)
{
volatile int result=0;
volatile int counter;

// write the S3 recort to the com port
text_write("S505");
text_write(IntToHexStr(records));

// calculate and write the checksum
result=5;
for (counter=0;counter<4;counter++) {
result+=(records&0xFF);
records>>=8;
}
result&=0xFF;
result=~result;
text_write(IntToHexByte(result));
}

Edited By PetriK on 1195851158

Lähetetty: **23 Marras 2007, 15:30**

Joko se SV1000:sen hemmo on saannut luettua Flash:n kokonaan?
Entä kirjoitus??

Edited By timo3 on 1195824709

Lähetetty: **23 Marras 2007, 17:41**

Käsittääkseni bozo on lukenut koko flashin jo lähes viikko sitten. Sillä vaan on vielä merkit väärässä järjestyksessä - tai ainakin siinä viestissä oli. Siinä mielessä tämä C ympäristö on hyvä kun sillä voi tehdä mitä vaan kun noi merkit sai käännettyä aika helposti.

Varsinaiseen dissassembler vaiheeseen ei ole vielä päässyt kukaan. Mutta olettaisin että ensi viikolla olisi ehkä mahdollista että olisi koodi käytettävissä niin että päästään etsimään tauluja. Mä yritän koodata nyt viikonlopun aikana noi S-recordit valmiiksi ja sitten saadaan testattua että kaikki toimii.

Kirjoittamisen osaltahan on jo aikoja sitten selvitetty että sarjaportin kautta tuo ohjelmointi onnistuu todella helposti. Bozo on kiinnostunut myös tekemään koodin jolla Flashiä kirjoitetaan - mutta se vaatii että ensin ram alueelle ladataan ohjelma joka osaa tehdä tuon kirjoittamisen ja sitten että jollain tavalla ram alueen ohjelma pystyy lukemaan koodia sellaisissa pätkissä että se voi kirjoittaa sitä flash muistiin. Vaatii pikkuisen assembler / c pätkän joka on paljon pidempi kuin tuo meikäläisen lukuohjelma. Tuossa tulee erilaiset kirjoittamisen ajoitukset todella kriittisiksi. Eli tavallaan pitää kirjoittaa AUD:lla ram alueelle jotenkin synkronoidusti niin että samaan aikaan koko ajan RAM aluella pyörivä ohjelma kirjoittaa FLASH muistiin. Musta ei ole vaivan arvoinen koska sarjaportin kautta kirjoittaminen on niin helppoa.

Mä käytän tuota sarjaportin kautta kirjoittamista monta kertaa päivässä, koska debuggeri ja ohjelmointilaite toimivat juuri sarjaportin ylitse. Prossuna on sh7086 mutta sarjaportin ohjelmointiominaisuuksien kannalta se on ihan samanlainen kuin sh7052. Eli kun saadaan koodi luettua ja varmistettua että se varmasti on oikein niin sitten voidaan kirjoittaa se takaisin sarjaportin kautta.

Edited By PetriK on 1195832598

Lähetetty: **23 Marras 2007, 22:16**

Ja sitten viimeinen (arvattavissa oleva haaste)...

Mitenkähän luotettavaksi tuon sarjaprotokollan voi saada normaalilla vuonvalvonnalla tällaisiin tietomassoihin mitä pitää siirtää?

Nyt joka 2-3000 rivi tulee vain 21 merkkiä vaikka tietueen koko on 22 merkkiä... En haluaisi kirjoittaa työasemaan vastaanottosoftaa kun ei ole siihen kehitysympäristöä... tosin tuo prosessorin lähetyspää on helppo koodata niin että se lähettää vaikka jostain luvusta uudestaan eteenpäin.

Tässä tuo konkreettinen ongelma:

S30900028C1032FF0640E1
S30900028C1428003C00F0
S30900028C184800800B0
S30900028C1C01F30C0C40

S3 tietuetyyppi
09 kaksimerkkistä tavua
xxxxxxxx muistosoite
yyyyyyyy muistosoitteen sisältö
zz tarkistussumma

No sen verran voin tunnustaa että vuonvalvonta on tällä hetkellä none. Voihan olla että xon/xoff tai dtr tai joku vastaava toimii... täytyy vaan tutkia että tukeeko prosessorin sio-moduuli sitä valmiiksi vai pitääkö täysin koodata itse. Nopeus on vain 19.2k, mutta hyvin liikkuu data tuollakin nopeudella koska 0xFFFFFFFF ei tarvitse siirtää ollenkaan.

Vastaanotto-ohjelmana on Tera Term...

Onko vinkkejä ?

Edited By PetriK on 1195851200

busanistit.org

Erilaisia ohjelmia aud datan lukemista varten - Joitain esimerkkejä