ATNEL tech-forum 2015-02-13T16:14:01+01:00 https://forum.atnel.pl/feed.php?f=4&t=9598&mode 2015-02-13T16:14:01+01:00 2015-02-13T16:14:01+01:00 https://forum.atnel.pl/viewtopic.php?t=9598&p=118778#p118778 <![CDATA[Re: ENC28J60 problem z komunikacją po SPI]]>
Pozwolę sobie powrócić do tematu... Więc swego czasu było już ok komunikacja ze sterownikiem po sieci działała...
Aż tu nagle... Więc wgrałem sobie programik serwera http z BB i okazuje się, że połączenie raz działa raz nie działa.
Obrazek
Zdarza się, że wyślę pinga do układu i na załączony obrazku widać, że odpowiedz idzie. Za drugim razem wyślę pinga... brak odpowiedzi. Dodam tylko, że połączenia na płytce sprawdzone. Czy ktoś z Was miał kiedyś podobny problem ?


Bardzo proszę o pomoc, bo zatruwa mi to kolejny dzień :x

Statystyki: Napisane przez jacky_cy — 13 lut 2015, o 16:14

]]> 2014-12-14T16:57:47+01:00 2014-12-14T16:57:47+01:00 https://forum.atnel.pl/viewtopic.php?t=9598&p=108655#p108655 <![CDATA[Re: ENC28J60 problem z komunikacją po SPI]]>

Statystyki: Napisane przez jacky_cy — 14 gru 2014, o 16:57

]]> 2014-12-13T01:23:15+01:00 2014-12-13T01:23:15+01:00 https://forum.atnel.pl/viewtopic.php?t=9598&p=108453#p108453 <![CDATA[Re: ENC28J60 problem z komunikacją po SPI]]> jacky_cy napisał(a):

postaram się wywalić CS na SS

Nie nie, trochę inaczej: nie musisz koniecznie używać tego pinu do sterowania modułem, wystarczy, że w czasie komunikacji z modułem na pinie SS będzie utrzymany stan wysoki. Tylko na czas transmisji, potem może sobie być jakikolwiek. Albo alternatywnie pin musi działać jako wyjście, wtedy już całkiem bez znaczenia co tam jest podłączone (niekoniecznie musi to być moduł eth) i jaki jest stan.
A co do innego ethernetu to niestety nie mogę pomóc, musisz pytać...

Statystyki: Napisane przez xor — 13 gru 2014, o 01:23

]]> 2014-12-12T22:05:34+01:00 2014-12-12T22:05:34+01:00 https://forum.atnel.pl/viewtopic.php?t=9598&p=108437#p108437 <![CDATA[Re: ENC28J60 problem z komunikacją po SPI]]>
Kurczę jak nie zaradzimy z softem co by ogarnąć CS na PD0 to się dosiądę jutro do lutownicy i postaram się wywalić CS na SS ATmegi.

Statystyki: Napisane przez jacky_cy — 12 gru 2014, o 22:05

]]> 2014-12-12T21:24:50+01:00 2014-12-12T21:24:50+01:00 https://forum.atnel.pl/viewtopic.php?t=9598&p=108429#p108429 <![CDATA[Re: ENC28J60 problem z komunikacją po SPI]]> Statystyki: Napisane przez xor — 12 gru 2014, o 21:24

]]> 2014-12-12T20:53:51+01:00 2014-12-12T20:53:51+01:00 https://forum.atnel.pl/viewtopic.php?t=9598&p=108426#p108426 <![CDATA[Re: ENC28J60 problem z komunikacją po SPI]]>
Obrazek

Statystyki: Napisane przez jacky_cy — 12 gru 2014, o 20:53

]]> 2014-12-12T13:34:37+01:00 2014-12-12T13:34:37+01:00 https://forum.atnel.pl/viewtopic.php?t=9598&p=108345#p108345 <![CDATA[Re: ENC28J60 problem z komunikacją po SPI]]> ) Możesz oczywiście jako CS użyć innego pinu ale niestety nie możesz zostawić pinu SS samopas. Trzeba go, o ile dobrze pamiętam, ustawić jako wyjście albo zostawiając jako wejście zapewnić na nim stan HIGH. Zapoznaj się z rozdziałem w dataszicie pt. "Pin SS in master mode", czy jakoś tak.

Statystyki: Napisane przez xor — 12 gru 2014, o 13:34

]]> 2014-12-12T12:38:09+01:00 2014-12-12T12:38:09+01:00 https://forum.atnel.pl/viewtopic.php?t=9598&p=108337#p108337 <![CDATA[Re: ENC28J60 problem z komunikacją po SPI]]>
Ale jeszcze raz przedstawię problem. Zacząłem mieszać ponieważ chciałbym, aby w moim projekcie linia CS od karty sieciowej była podpięta pod pin PD0 uC. Stąd moje kombinacje...

Jeśli chodzi o podpięcie się pod pin SS ATmegi to komunikacja między kartą a uC działa bez zarzutu. Natomiast problem pojawił się gdy CS zamiast pod PB4 miałby być podpięty pod PD0 (chyba da się?).

Statystyki: Napisane przez jacky_cy — 12 gru 2014, o 12:38

]]> 2014-12-09T14:11:04+01:00 2014-12-09T14:11:04+01:00 https://forum.atnel.pl/viewtopic.php?t=9598&p=107930#p107930 <![CDATA[Re: ENC28J60 problem z komunikacją po SPI]]> [syntax=c]#if defined(__AVR_ATmega644__)||defined(__AVR_ATmega644P__)[/syntax]
Powinieneś wpisać takie coś:
[syntax=c]#if defined(__AVR_ATmega644__)||defined(__AVR_ATmega644P__)||defined(__AVR_ATmega32__)[/syntax]
Dzięki temu kompilator sam wykryje jaki masz podpięty procesor i odpowiednio Twój program zdefiniuje piny.

Statystyki: Napisane przez frog — 9 gru 2014, o 14:11

]]> 2014-12-08T22:09:54+01:00 2014-12-08T22:09:54+01:00 https://forum.atnel.pl/viewtopic.php?t=9598&p=107874#p107874 <![CDATA[ENC28J60 problem z komunikacją po SPI]]>
Otóż z pomocą bluebooka chciałem zaprzęgnąć kartę sieciową na ENC28J60 do współpracy z moim sterownikiem. Problem pojawił się już na wstępie z komunikacją po SPI (w sumie pierwsza moja próba z komunikacją czegokolwiek po SPI). W sumie robiłem wszystko krok po kroku jak w książce (biblioteki z tuxgraphics.org), lecz zmieniłem trochę plik enc28j60.c Wstawiam oryginalny plik ze stronki:

[syntax=c]/*********************************************
* vim:sw=8:ts=8:si:et
* To use the above modeline in vim you must have "set modeline" in your .vimrc
* Author: Guido Socher
* Copyright:LGPL V2
* See http://www.gnu.org/licenses/old-licenses/lgpl-2.0.html
*
* Based on the enc28j60.c file from the AVRlib library by Pascal Stang.
* For AVRlib See http://www.procyonengineering.com/
* Used with explicit permission of Pascal Stang.
*
* Title: Microchip ENC28J60 Ethernet Interface Driver
* Chip type : ATMEGA88/ATMEGA168/ATMEGA328/ATMEGA644 with ENC28J60
*********************************************/
#include <avr/io.h>
#include "ip_config.h"
#include "enc28j60.h"
//
#ifndef F_CPU
#define F_CPU 12500000UL // 12.5 MHz
//#else
//#warning "F_CPU was already defined"
#endif

#ifndef ALIBC_OLD
#include <util/delay_basic.h>
#else
#include <avr/delay.h>
#endif


static uint8_t Enc28j60Bank;
static int16_t gNextPacketPtr;
#define ENC28J60_CONTROL_PORT PORTB
#define ENC28J60_CONTROL_DDR DDRB
#if defined(__AVR_ATmega88__) || defined(__AVR_ATmega88P__) || defined(__AVR_ATmega168__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__)
#define ENC28J60_CONTROL_CS PORTB2
#define ENC28J60_CONTROL_SO PORTB4
#define ENC28J60_CONTROL_SI PORTB3
#define ENC28J60_CONTROL_SCK PORTB5
#endif
#if defined(__AVR_ATmega644__)||defined(__AVR_ATmega644P__)
#define ENC28J60_CONTROL_CS PORTB4
#define ENC28J60_CONTROL_SO PORTB6
#define ENC28J60_CONTROL_SI PORTB5
#define ENC28J60_CONTROL_SCK PORTB7
#endif
// set CS to 0 = active
#define CSACTIVE ENC28J60_CONTROL_PORT&=~(1<<ENC28J60_CONTROL_CS)
// set CS to 1 = passive
#define CSPASSIVE ENC28J60_CONTROL_PORT|=(1<<ENC28J60_CONTROL_CS)
//
#define waitspi() while(!(SPSR&(1<<SPIF)))

uint8_t enc28j60ReadOp(uint8_t op, uint8_t address)
{
CSACTIVE;
// issue read command
SPDR = op | (address & ADDR_MASK);
waitspi();
// read data
SPDR = 0x00;
waitspi();
// do dummy read if needed (for mac and mii, see datasheet page 29)
if(address & 0x80)
{
SPDR = 0x00;
waitspi();
}
// release CS
CSPASSIVE;
return(SPDR);
}

void enc28j60WriteOp(uint8_t op, uint8_t address, uint8_t data)
{
CSACTIVE;
// issue write command
SPDR = op | (address & ADDR_MASK);
waitspi();
// write data
SPDR = data;
waitspi();
CSPASSIVE;
}

void enc28j60ReadBuffer(uint16_t len, uint8_t* data)
{
CSACTIVE;
// issue read command
SPDR = ENC28J60_READ_BUF_MEM;
waitspi();
while(len)
{
len--;
// read data
SPDR = 0x00;
waitspi();
*data = SPDR;
data++;
}
*data='\0';
CSPASSIVE;
}

void enc28j60WriteBuffer(uint16_t len, uint8_t* data)
{
CSACTIVE;
// issue write command
SPDR = ENC28J60_WRITE_BUF_MEM;
waitspi();
while(len)
{
len--;
// write data
SPDR = *data;
data++;
waitspi();
}
CSPASSIVE;
}

void enc28j60SetBank(uint8_t address)
{
// set the bank (if needed)
if((address & BANK_MASK) != Enc28j60Bank)
{
// set the bank
enc28j60WriteOp(ENC28J60_BIT_FIELD_CLR, ECON1, (ECON1_BSEL1|ECON1_BSEL0));
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, (address & BANK_MASK)>>5);
Enc28j60Bank = (address & BANK_MASK);
}
}

uint8_t enc28j60Read(uint8_t address)
{
// set the bank
enc28j60SetBank(address);
// do the read
return enc28j60ReadOp(ENC28J60_READ_CTRL_REG, address);
}

// read 16 bits
uint16_t enc28j60PhyRead(uint8_t address)
{
// Set the right address and start the register read operation
enc28j60Write(MIREGADR, address);
enc28j60Write(MICMD, MICMD_MIIRD);
// wait until the PHY read completes
while(enc28j60Read(MISTAT) & MISTAT_BUSY);
// reset reading bit
enc28j60Write(MICMD, 0x00);
// get data value from MIRDL and MIRDH
return ((enc28j60Read(MIRDH)<<8)|enc28j60Read(MIRDL));
}

void enc28j60Write(uint8_t address, uint8_t data)
{
// set the bank
enc28j60SetBank(address);
// do the write
enc28j60WriteOp(ENC28J60_WRITE_CTRL_REG, address, data);
}

void enc28j60PhyWrite(uint8_t address, uint16_t data)
{
// set the PHY register address
enc28j60Write(MIREGADR, address);
// write the PHY data
enc28j60Write(MIWRL, data);
enc28j60Write(MIWRH, data>>8);
// wait until the PHY write completes
while(enc28j60Read(MISTAT) & MISTAT_BUSY){
_delay_loop_1(40); // 10us
}
}

void enc28j60clkout(uint8_t clk)
{
//setup clkout: 2 is 12.5MHz:
enc28j60Write(ECOCON, clk & 0x7);
}

void enc28j60Init(uint8_t* macaddr)
{
// initialize I/O
// ss as output:
ENC28J60_CONTROL_DDR |= 1<<ENC28J60_CONTROL_CS;
CSPASSIVE; // ss=0
//
ENC28J60_CONTROL_DDR |= 1<<ENC28J60_CONTROL_SI | 1<<ENC28J60_CONTROL_SCK; // mosi, sck output
ENC28J60_CONTROL_DDR&=~(1<<ENC28J60_CONTROL_SO); // MISO is input
//
ENC28J60_CONTROL_PORT&=~(1<<ENC28J60_CONTROL_SI); // MOSI low
ENC28J60_CONTROL_PORT&=~(1<<ENC28J60_CONTROL_SCK); // SCK low
//
// initialize SPI interface
// master mode and Fosc/2 clock:
SPCR = (1<<SPE)|(1<<MSTR);
SPSR |= (1<<SPI2X);
// perform system reset
enc28j60WriteOp(ENC28J60_SOFT_RESET, 0, ENC28J60_SOFT_RESET);
_delay_loop_2(0); // 20ms
// check CLKRDY bit to see if reset is complete
// The CLKRDY does not work. See Rev. B4 Silicon Errata point. Just wait.
//while(!(enc28j60Read(ESTAT) & ESTAT_CLKRDY));
// do bank 0 stuff
// initialize receive buffer
// 16-bit transfers, must write low byte first
// set receive buffer start address
gNextPacketPtr = RXSTART_INIT;
// Rx start
enc28j60Write(ERXSTL, RXSTART_INIT&0xFF);
enc28j60Write(ERXSTH, RXSTART_INIT>>8);
// set receive pointer address
enc28j60Write(ERXRDPTL, RXSTART_INIT&0xFF);
enc28j60Write(ERXRDPTH, RXSTART_INIT>>8);
// RX end
enc28j60Write(ERXNDL, RXSTOP_INIT&0xFF);
enc28j60Write(ERXNDH, RXSTOP_INIT>>8);
// TX start
enc28j60Write(ETXSTL, TXSTART_INIT&0xFF);
enc28j60Write(ETXSTH, TXSTART_INIT>>8);
// TX end
enc28j60Write(ETXNDL, TXSTOP_INIT&0xFF);
enc28j60Write(ETXNDH, TXSTOP_INIT>>8);
// do bank 1 stuff, packet filter:
// For broadcast packets we allow only ARP packtets
// All other packets should be unicast only for our mac (MAADR)
//
// The pattern to match on is therefore
// Type ETH.DST
// ARP BROADCAST
// 06 08 -- ff ff ff ff ff ff -> ip checksum for theses bytes=f7f9
// in binary these poitions are:11 0000 0011 1111
// This is hex 303F->EPMM0=0x3f,EPMM1=0x30
enc28j60Write(ERXFCON, ERXFCON_UCEN|ERXFCON_CRCEN|ERXFCON_PMEN);
enc28j60Write(EPMM0, 0x3f);
enc28j60Write(EPMM1, 0x30);
enc28j60Write(EPMCSL, 0xf9);
enc28j60Write(EPMCSH, 0xf7);
//
//
// do bank 2 stuff
// enable MAC receive
enc28j60Write(MACON1, MACON1_MARXEN|MACON1_TXPAUS|MACON1_RXPAUS);
// bring MAC out of reset
enc28j60Write(MACON2, 0x00);
// enable automatic padding to 60bytes and CRC operations
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, MACON3, MACON3_PADCFG0|MACON3_TXCRCEN|MACON3_FRMLNEN);
// set inter-frame gap (non-back-to-back)
enc28j60Write(MAIPGL, 0x12);
enc28j60Write(MAIPGH, 0x0C);
// set inter-frame gap (back-to-back)
enc28j60Write(MABBIPG, 0x12);
// Set the maximum packet size which the controller will accept
// Do not send packets longer than MAX_FRAMELEN:
enc28j60Write(MAMXFLL, MAX_FRAMELEN&0xFF);
enc28j60Write(MAMXFLH, MAX_FRAMELEN>>8);
// do bank 3 stuff
// write MAC address
// NOTE: MAC address in ENC28J60 is byte-backward
enc28j60Write(MAADR5, macaddr[0]);
enc28j60Write(MAADR4, macaddr[1]);
enc28j60Write(MAADR3, macaddr[2]);
enc28j60Write(MAADR2, macaddr[3]);
enc28j60Write(MAADR1, macaddr[4]);
enc28j60Write(MAADR0, macaddr[5]);
// no loopback of transmitted frames
enc28j60PhyWrite(PHCON2, PHCON2_HDLDIS);
// switch to bank 0
enc28j60SetBank(ECON1);
// enable interrutps
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, EIE, EIE_INTIE|EIE_PKTIE);
// enable packet reception
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_RXEN);
}

// read the revision of the chip:
uint8_t enc28j60getrev(void)
{
uint8_t rev;
rev=enc28j60Read(EREVID);
// microchip forgott to step the number on the silcon when they
// released the revision B7. 6 is now rev B7. We still have
// to see what they do when they release B8. At the moment
// there is no B8 out yet
if (rev>5) rev++;
return(rev);
}

// dhcp_client.c needs general broadcast
#ifdef ENC28J60_BROADCAST
// A number of utility functions to enable/disable general broadcast (not just arp)
void enc28j60EnableBroadcast( void ) {
enc28j60Write(ERXFCON, (uint8_t)((enc28j60Read(ERXFCON) | ERXFCON_BCEN)));
}
void enc28j60DisableBroadcast( void ) {
enc28j60Write(ERXFCON, enc28j60Read(ERXFCON) & (0xff ^ ERXFCON_BCEN));
}
#endif

// link status
uint8_t enc28j60linkup(void)
{
// PHSTAT1 LLSTAT (= bit 2 in lower reg), PHSTAT1_LLSTAT
// LLSTAT is latching, that is: if it was down since last
// calling enc28j60linkup then we get first a down indication
// and only at the next call to enc28j60linkup it will come up.
// This way we can detect intermittened link failures and
// that might be what we want.
// The non latching version is LSTAT.
// PHSTAT2 LSTAT (= bit 10 in upper reg)
if (enc28j60PhyRead(PHSTAT2) & (1<<10) ){
//if (enc28j60PhyRead(PHSTAT1) & PHSTAT1_LLSTAT){
return(1);
}
return(0);
}

void enc28j60PacketSend(uint16_t len, uint8_t* packet)
{
// Check no transmit in progress
while (enc28j60ReadOp(ENC28J60_READ_CTRL_REG, ECON1) & ECON1_TXRTS);
//
// Reset the transmit logic problem. Unblock stall in the transmit logic.
// See Rev. B4 Silicon Errata point 12.
if( (enc28j60Read(EIR) & EIR_TXERIF) ) {
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_TXRST);
enc28j60WriteOp(ENC28J60_BIT_FIELD_CLR, ECON1, ECON1_TXRST);
enc28j60WriteOp(ENC28J60_BIT_FIELD_CLR, EIR, EIR_TXERIF);
_delay_loop_2(30000); // 10ms
}
// Set the write pointer to start of transmit buffer area
enc28j60Write(EWRPTL, TXSTART_INIT&0xFF);
enc28j60Write(EWRPTH, TXSTART_INIT>>8);
// Set the TXND pointer to correspond to the packet size given
enc28j60Write(ETXNDL, (TXSTART_INIT+len)&0xFF);
enc28j60Write(ETXNDH, (TXSTART_INIT+len)>>8);
// write per-packet control byte (0x00 means use macon3 settings)
enc28j60WriteOp(ENC28J60_WRITE_BUF_MEM, 0, 0x00);
// copy the packet into the transmit buffer
enc28j60WriteBuffer(len, packet);
// send the contents of the transmit buffer onto the network
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_TXRTS);
}

// just probe if there might be a packet
uint8_t enc28j60hasRxPkt(void)
{
if( enc28j60Read(EPKTCNT) ==0 ){
return(0);
}
return(1);
}

// Gets a packet from the network receive buffer, if one is available.
// The packet will by headed by an ethernet header.
// maxlen The maximum acceptable length of a retrieved packet.
// packet Pointer where packet data should be stored.
// Returns: Packet length in bytes if a packet was retrieved, zero otherwise.
uint16_t enc28j60PacketReceive(uint16_t maxlen, uint8_t* packet)
{
uint16_t rxstat;
uint16_t len;
// check if a packet has been received and buffered
//if( !(enc28j60Read(EIR) & EIR_PKTIF) )
// The above does not work. See Rev. B4 Silicon Errata point 6.
if( enc28j60Read(EPKTCNT) ==0 ){
return(0);
}

// Set the read pointer to the start of the received packet
enc28j60Write(ERDPTL, (gNextPacketPtr &0xFF));
enc28j60Write(ERDPTH, (gNextPacketPtr)>>8);
// read the next packet pointer
gNextPacketPtr = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
gNextPacketPtr |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8;
// read the packet length (see datasheet page 43)
len = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
len |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0)<<8;
len-=4; //remove the CRC count
// read the receive status (see datasheet page 43)
rxstat = enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0);
rxstat |= ((uint16_t)enc28j60ReadOp(ENC28J60_READ_BUF_MEM, 0))<<8;
// limit retrieve length
if (len>maxlen-1){
len=maxlen-1;
}
// check CRC and symbol errors (see datasheet page 44, table 7-3):
// The ERXFCON.CRCEN is set by default. Normally we should not
// need to check this.
if ((rxstat & 0x80)==0){
// invalid
len=0;
}else{
// copy the packet from the receive buffer
enc28j60ReadBuffer(len, packet);
}
// Move the RX read pointer to the start of the next received packet
// This frees the memory we just read out
//enc28j60Write(ERXRDPTL, (gNextPacketPtr &0xFF));
//enc28j60Write(ERXRDPTH, (gNextPacketPtr)>>8);
//
// Move the RX read pointer to the start of the next received packet
// This frees the memory we just read out.
// However, compensate for the errata point 13, rev B4: never write an even address!
// gNextPacketPtr is always an even address if RXSTOP_INIT is odd.
if (gNextPacketPtr -1 > RXSTOP_INIT){ // RXSTART_INIT is zero, no test for gNextPacketPtr less than RXSTART_INIT.
enc28j60Write(ERXRDPTL, (RXSTOP_INIT)&0xFF);
enc28j60Write(ERXRDPTH, (RXSTOP_INIT)>>8);
} else {
enc28j60Write(ERXRDPTL, (gNextPacketPtr-1)&0xFF);
enc28j60Write(ERXRDPTH, (gNextPacketPtr-1)>>8);
}
// decrement the packet counter indicate we are done with this packet
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON2, ECON2_PKTDEC);
return(len);
}[/syntax]

A to moje modyfikacje na potrzeby ATmegi32 i linii CS podpiętej do pinu PD0:

[syntax=c]#define ENC28J60_CONTROL_PORT PORTB
#define ENC28J60_CONTROL_DDR DDRB

#define CS_CONTROL_PORT PORTD
#define CS_CONTROL_DDR DDRD


#define ENC28J60_CONTROL_CS PORTD0
#define ENC28J60_CONTROL_SO PORTB6
#define ENC28J60_CONTROL_SI PORTB5
#define ENC28J60_CONTROL_SCK PORTB7

// set CS to 0 = active
#define CSACTIVE CS_CONTROL_PORT&=~(1<<ENC28J60_CONTROL_CS)
// set CS to 1 = passive
#define CSPASSIVE CS_CONTROL_PORT|=(1<<ENC28J60_CONTROL_CS)[/syntax]
oraz
[syntax=c]void enc28j60Init(uint8_t* macaddr)
{
// initialize I/O
// ss as output:
CS_CONTROL_DDR |= 1<<ENC28J60_CONTROL_CS;[/syntax]

W każdym razie karta sieciowa nie komunikuje się z prockiem, więc bardzo Was proszę i naprowadzenie mnie gdzie robię jakąś gafę.

Dopasowanie sygnałów na podstawie schematu w książce na 74AC125D. Schemat:

Obrazek

uC taktowany zewnętrznym kwarcem 16MHz, połączenia sprawdzone.

Statystyki: Napisane przez jacky_cy — 8 gru 2014, o 22:09

]]>