LED 전광판

AVR Project 조회 수 33970 추천 수 517 2004.12.22 11:06:58

http://home.wanadoo.nl/electro1/avr/dotmatrix.htm 개발자 사이트 : http://home.wanadoo.nl/electro1/avr/dotmatrix.htm

관련    사이트 : http://www.edaboard.com/ftopic58756-30.html

74H595 Shift Register App : http://www.kronosrobotics.com/an137/DAN137.shtml

On this page you will find a scrolling LED sign based on the AT90S2313 AVR microcontroller, which you can build yourself (when finished) Other names for this device can be: Moving message sign, Message crawler, Scrolling message, message display, etc.
The idea is to let a text scroll over the LED dot-matrix displays. A dot-matrix display is a display which contains 5x7 dots (LEDs) in one case, the LEDs are connected like a matrix, there are two types CC and CA, the LEDs are simply put the other way around, here the drawings (inside and front):

The 5x7 LED matrixThe drawing from the datasheet

If you put 1.8 Volt e.g. at the lines 4 and 10, that LED (dot) will lit, the trick of multiplexing is to scan the columns (5) and set the data on the rows (7) (or visa-versa), the multiplex-frequency must be greater than approx. 40Hz else you will see the flickering of the LEDs to much (take about 5 msec per column, thats about 25 msec for one frame)
The scanning goes as follows, first set the rows data on the 7 rows e.g. 1010010, then activate (0 or 1 -> depends on which type CA = common cathode, or CC = common anode) the first column, now these LEDs (dots) will lit, wait 5 msec, then switch the column off, now load the next rows data, and set the second column on, wait 5 msecs again, and switch it off again, if you repeat this sequence very fast, you will see the data (character data) appear on the display (refresh frequency 40 - 70Hz is ok, don't take twice or half the artificial light-frequency of 50/60 Hz)
The rows data comes e.g. from the EEPROM or flash memory of the AVR, you can also take an external EEPROM/flash IC, the AT90S2313 has 128 bytes EEPROM and 2k of flash memory, what you can do is put the character data (ASCII) into the flash memory (read below for more details) Next the test-diagram:

A test diagram
The 74HC595 is an 8-bit shift-register IC, with this IC you can shift 8 bits to the outputs with only 3 wires, that are Data (Ds), and 2 shift inputs (SHcp, STcp), connect like the diagram. How does the 74HC595 works? First shift the 8 bits into the stages with SHcp, then shift the stages to the outputs with STcp, this causes the outputs to switch in one go, with e.g. a 74HCT164 you can only shift the bits into the outputs, the advantage of the 74HC595 is the storage register. Don't forget that multiplexing causes the LEDs only lit up for a fraction, so if you want the same intensity you must put more current through them, this diagram is for practice and programming, wants you have it working you can put transistors and resistors on. Here I put the letter R on the display as you can see, using a little breadboard: (next: How the scrolling is done...)
R on the display.. :)

How to scroll a character accross the display ? The trick is to build one character on the display by scanning the columns very fast, and let say each 20 times (20 frames) scroll it one position to the left, this will give the effect of a walking text accross the dot-matrix display. So first build one frame, repeat this 20 times, and after that, read the data one address later, if you do this 5 times (5 columns) the character scroll from right to left from the display. (the refresh goes so fast that your brain can't keep up, and what you see is the R scrolling over the display) Btw, I will take five 74HC595's shiftregisters IC's, that are 5 x 8 bit = 40 bits / 5 columns = 8 dot-matrix displays, making it a nice tiny message sign.

Example on how to build one char and scroll it left

What I am going to do is putting ASCII data (thats 128 x 5 bytes = 640 bytes) into the 2k flash memory of the AT90S2313, then I have 704 words left for my program, that can really be a huge program!, because I used only 69 lines (69 instructions) of program so far, and that scrolls characters fluently accross the dot-matrix display. I made the program so that you can set the scroll-speed, from 0 - 255, so 256 speeds, 25 fps (frames/second) is a nice speed. On one of my pages (this page) I am using a 2-bit Gray code rotary encoder, with this encoder I will make an edit function in the software, so you can edit messages, without a keyboard, this save space, this type of rotary encoder has a push-function in the shaft, so e.g. after you select a character you can store that in memory.

Next more details about how the scrolling is done.

I came up with this simple scroller formula:

adrs = counter + pointer

'adrs' is the register which will read the address to fetch data from, 'counter' is a bit-counter which counts up from 0 to 4 (5 columns), and 'pointer' is the register which INCreases every so many frames. The program starts from zero, so 'counter' and 'pointer' are both zero in the first round, so the first Rows data for the 1st column will be fetched from the 1st address (0). What also must happen is let a small routine INCrease with one after 'counter' resets to zero, at that moment one frames is build (1 image = 1 character) and count that. The next round 'counter' will go to 1, and so 'adrs' will be also 1 because 'pointer' only INCreases each lets say 25 times (25 frames), so after 25 times 'pointer' INCreases with one, and then the first round will be: adrs = 0 + 1 = 1, the second round that will be 2, so you see the reading from the address is shifted one position to the left, because you INC. You can also scroll backwards, simply DEC the routine where 'pointer' is counted each 25 frames. Make the whole sequence run at a speed of about 25 msec, that will make the display refesh at 40 Hz. Here a few pictures of a scrolling an 'R' across the display:

frame 1frame 2frame 3frame 4frame 5
Click here to see an animation (124kB), or click here to see an AVI movie (1MB)

As you can see, my webCAM (CAM was capturing at 30 fps btw) wasn't able to capture the 4th picture very well, at that moment it was just shifting left one position (the pointer INCreased at that moment) What you see are 10 EEPROM addresses filled with data like this:


.db 0b00000000 ;address 0
.db 0b00000000 ;address 1
.db 0b00000000 ;address 2
.db 0b00000000 ;address 3
.db 0b00000000 ;address 4
.db 0b01111111 ;address 5
.db 0b00001001 ;address 6
.db 0b00011001 ;address 7
.db 0b00101001 ;address 8
.db 0b01000110 ;address 9

I did rotate the data 90 degrees in the EEPROM, so I can easely fetch the Rows data, each EEPROM address is one Row of data, so one character are 5 addresses (5 bytes) This Rows data is than set to PORTB of the AT90S2313 when each column is active. If you are at the point that the 'R' is on-display, scroll it backwards, so that it looks like if the 'R' is shifted on and off the display, ofcourse you can do many tricks e.g. normal scrolling (western is leftways), backwards, up- and downwards, even diagonal in each direction, or you can make symbols, or icons which move while scrolling, the possibilities are almost endless.

How to get the full intensity from the displays ?

The scanning of the LEDs (dots) of the dotmatrix display takes 25 msec (40Hz refresh), so each LED is On for 5 msec (or Off when the data is '0'), because each column is On for 5 msec. One dot needs 10 mA of constant current, but when it goes on and off with a high speed, the intensity will decrease, so you need to put more current through the LEDs to have the same effect (same at 0Hz) Incresing the current can be done with transistors or a driver IC (like ULN2803, etc.) The dots have a duty-cycle of 20%, each LED is on for 20% of the total refresh time (Tref = 25 msec), so 5 msec On and 20 msec Off (see picure below):

duty-cycle dots

But the On / Off time of each dot is 5 msec -> On for 5 msec, so thats only 5/1000th of a second! Now how much current is needed to have the same light-intensity ? Here the formula you can use:

I-led = T-tot / On-time * Normal Current

Where T-tot = the time from one rising edge to another.
On-time = the time that the LED is actually on.
Normal Current = the current the LED can handle at DC (continuesly on -> see datasheet dotmatrix display)

In this scroller project this will be:

The normal current = 10 mA per dot, the new current must be: 25 msec / 5 msec * 10 mA = 50 mA. So the current needs to be 5 times higher, for having the same LED intensity. The voltage over one dot Vf (forward LED voltage), will be average lower (PWM style of signal fed on each dot) For increasing the current, take a simple transistor like the BC327/BC337. The resistors have to be calculated (I didn't), because you can't only take a bare transistor, the basis-current of the transistor needs to be limited with a resistor, else the transistor will damage. Here a diagram which presents one dot:

current through dot of dotmatrix display

You can also take a cheap transistor (BC337 and R's) instead of the ULN2003A if you really wanna go for low-cost, but the PCB (printed circuit board) will be a lot more difficult to fix (more tracks, cause each transistor has 3 wires), the advantage of the ULN2003A is that is can sink up to 500 mA max. The 74HC595 steers the colums (5 per dotmatrix display) via the ULN2003A current driver, the AVR the 7 rows (character data), you cannot take the i/o's of the AVR directly, because it can only source up to 20 mA per i/o, and the dot(s) need 50 mA each at this switching speed (40 Hz)

How reading data from the internal Flash memory of the AT90S2313 ?

This AVR has 2k (2048 bytes) of Flash memory. Flash memory can be written for 1000 times quaranteed (probably 10 times more) This memory can be used for two purposes, program storage or data storage, or both. When you want to store all ASCII characters (I will take the ASCII set of the SLO2016), that are 0 to 127 = 128 characters in, you need 128 x 5 bytes = 640 bytes of memory space) Here a few characters on the dotmatrix display:

Few of the 128 symbols: ?0#@$ etc.
Here a few of the 128 symbols of the ASCII set now in Flash memory.

The AVR is not an extremely complecated microcontroller, simply put a table at the end of your code, like this:

.db 0b01111111,0b00001001 ;char0
.db 0b00011001,0b00101001 ;char0
.db 0b01000110,'#' ;char0

This data presents one ASCII sign (the R) The Flash memory is 16bit wide, I did split the table up this way, so you can see the rowsdata very clearly. The '#' sign is the end symbol, in the routine you can do a compare:

cpi data, '#'

When it reaches this point, let the routine branch to another routine, or back to the mainloop, whatever. Or you can set an end label, at the end of the ASCII table, like this:

.db 0b01000110,0b00110010

Remember that when the Z pointers are at end of the table, they are exually sitting on top of the label 'end_ASCII', and that means the data you read are all 1's, because at init Flash was filled with 1's. Now you wonder, how can you walk through the Flash memory ? First you must initialize the Z pointers (set them at begin table), use these two lines of assembly:

ldi ZL, LOW(ASCII*2) ;set Low memory pointer
ldi ZH, HIGH(ASCII*2) ;set High memory pointer

You can see clearly the Low and High pointer. Now you can use an instruction called 'lpm' (load program memory) for reading the data from the internal Flash memory of the AVR, the reading starts right away from the label called 'ASCII:' The data from the table will be stored in r0 (first register of the AT90S2313), 'lpm' does this. Once it's in r0, you can use it in your program, you can set the data e.i. to PORTB, like this:

lpm ;loads the data in r0
out PORTB, data ;sets the data at PORTB pins

Don't forget to define 'data' , so:

.def data = r0

Now you still wonder, how can I fetch the next byte from the Flash memory ? You can use:

inc ZL ;increases Lower pointer by one

This line will fetch from the next low address in memory. It is not nessesary to organize the memory, simply put the table at the end of the program. When the program gets larger the data will be shifted forward automatically by the assembler. The assembler will give an errormessage when the end of the memory is reached. With this trick you have to be carefull, your table can't be to long, because when the low byte (ZL) will continue adding up, the high byte (ZH) will stay the same the whole time, and then you've got a major problem! So than use this:

adiw ZL, 1 ;increases Z pointers by one

I.e. suppose you start at 0x02FA (02 = high byte; ZH, FA = low byte; ZL), when reaching 0x02FF, it should go to 0x0300, but if you only use ZL it will go back to 0x0200 instead of 0x0300! Here an example program, which blinks two LEDs (or when the '#' is changed from postion it will walk 8 LEDs on PORTB) from memory. Here the SLO2016 ASCII set which I'm gonna use :)

The table consists of 128 characters (128 x 5 bytes x 8 bits = 5120 bits totall)

With the 128 bytes internal EEPROM of the AT90S2313 you can store up to 128 characters max. , not very much text can be stored, but enough for a short message, little story, anouncement, a few prices of some products i.e. , valuta courses, etc. So the number 65 (0x41) stored in EEPROM will display the 'A' , etc. You can take the rest of the Flash memory for permanent words or special characters, just make another table. The permanent words can be a few standard words, this saves editing.

How to store/load data from and to the internal SRAM memory of the AT90S2313 ?

First of all, RAM = Random Access Memory, S means Static. There are to ways to do this. One is direct, the other is indirect by means of the so called Y pointers (YL and YH) Remember that the data in SRAM will be gone when you take the power off the AT90S2313. In this example the indirect methode. The SRAM area for the AT90S2313 starts at location $60 = 0x0060 = 0x60, so first define this number:

.equ SRAM = 0x60

Next setup the Y pointer:

ldi YL, SRAM ;set memory pointer

Now the Y pointer is set to SRAM location 0x60 (start of SRAM) How can I store data in an SRAM location ? This is very simple. Suppose you want to store temporary (one byte) data in the first SRAM location, then do this:

st Y, temp ;store data in SRAM

Now the data in the register 'temp' sits in the first SRAM location, because the Y pointer was set to that position in the first place. Now how can I store the same temporary data in the 2nd SRAM location ? Simply increase the Y pointer, or even simpler, use the '+' sign, like this:

st Y+, temp ;store data in next SRAM location

The '+' sign means move Y one position upwards, if you wanna go downwards, then use the '-' sign, but in front of the Y:

st -Y, temp ;store data in one SRAM location lower

So now you can move the Y pointer up- or downwards. Now how to read data back from SRAM in a register ? Use the instruction LD (load):

ld temp, Y ;load data from SRAM

You again can use the parameters '+' or '-' . What also can be used are two other instructions STD and LDD (indirect store/load), with these two you can very easely store/load data to/from any location without changing the Y pointer's position. The Y pointer will come back to the last set position. Here an example:

ldd temp, Y+1 ;load Y+1 into temp
std Y+0, temp ;store temp into Y+0

Y+1 means; load/store from/to one position upward in memory, you can also use names instead of numbers:

.equ value = 6

std Y+value, data ;store data into Y+value (Y+6)

Change the position of the Y pointers with:

adiw YL, 1 ;move Y pointers one position upward


sbiw YL, 1 ;move Y pointers one position downward

On the next pages you will find more about this moving message sign project....

The next phase; working towards a (test) diagram:

I decided to take a 74HC138 for scanning the Rows of the dotmatrix display, and using 74HC595's for the Columns (16 displays x 5 Columns = 80 Columns totall -> 80 bits per Row / 1 byte -> ten 74HC595's are needed) The 74HC138 is a 3-to-8 line decoder/demultiplexer, with only 3 wires (A0, A1 and A2) you can set one output (Y0-Y7) low at a time, this is why I took this particular IC, you can only activate one Row at a time. Connect the 74HC138 to an AVR microcontroller type AT90S2313, like this:

Connecting the 74HC138
Only 3 wires are needed (saves 5 i/o's of the AVR)

Don't connect the opposite way the bits are, else the software will be more complicated (connect bitwise; msb <- lsb) The 74HC138 is normally enabled (E1, E2 to GND, E3 to Vcc) now, see function table in the datasheet. Now you can let the AVR switch the 3 address lines A0, A1, A2. The software can be setup like this:

.equ A0 = 0 ;address A0 to PB0
.equ A1 = 1 ;address A1 to PB1
.equ A2 = 2 ;address A2 to PB2

sbi DDRB, A0 ;output PB0
sbi DDRB, A1 ;output PB1
sbi DDRB, A2 ;output PB2

cbi PORTB, A0 ;A0 low
cbi PORTB, A1 ;A1 low
cbi PORTB, A1 ;A2 low

This part assembly (one possibility), let address Y0 of the 74HC138 become low (active), the other 7 address lines (Y1 to Y7) are in high state (+Vcc) Connect the address lines to the Rows of an Anode type (Common Anodes) LED dotmatrix display. The Columns are connected to a 74HC595 (making a bit 'hi' switches a dot On, bit 'lo' switches it Off), this way you can make an ASCII table (like the one of an

Testing the 74HC138
The 74HC138 under test.

Now make a 3 bits counter, start at 000, after 7 times, or when the counter reaches 7, let it reset. In between each count, insert new data for the columns. If you use the bits 3 4 and 5 i.e., first read the port, than add the new value and restore the port, else you will set the other bits (i/o's) to zero. On the next page a simplified diagram with 8 dotmatrix displays, which will be used for software debugging, here using a 74HC259 (inversing polarity)

Writing and debugging the software:

This page describes how to write the software for a moving message sign with 8 LED dotmatrix displays, and how to build the debugging-hardware for it. The diagram below shows the complete circuit (hardware) for debugging the software (diagram can be used for test purposes) With this diagram the dots of the dotmatrix displays won't get their full intensity (currents), so the dots won't lite up fully, but enough for debugging (to see what happens) the software for the final version (you first need working software, then you can let the final hardware work) If you make a mistake when writing the routines, the dots won't blow, because they have limiting resistors, the current is limited to about 9 mA max. The totall voltage (max. +5V) drops over the resistor, the dot and the ULN2003 output circuitry (see ULN2003 datasheet for more details)

Diagram for debugging the software...
This simplefied diagram will be used for debugging the software.

The current for each dot is delivered by the 74HC595 outputs (can source about 25mA max.) The current for the Row(s) will be sinked by the ULN2003. The 74HC259 switches the Rows, one at the time (Rows scan) The sequence can be as follow; Set data ready on the 74HC595 stages, activate the first Row (Q0 of HC259 active), then store the data at the 74HC595's outputs, wait a few msec, and switch the outputs of the 74HC595's off again, then switch the 74HC259 to the next Row (3-bit upcounter), and repeat this 7 times (7 Rows) This is one complete frame, so one frame is 7 x 40 dots = 280 dots. One complete frame (image) must be set on the displays faster than you can observe. The diagram shows one line with all 74HC595 outputs high state (all dots first Row On) If you watch the diagram closely, you see the 74HC595 outputs are drawn bitwise, from Q0 to Q7 (one byte for each shift-register), so 5 bytes (5 x 8 = 40 bits) of (serial) are data needed for each Row, so a totall for the whole display of 5 x 7 = 35 bytes.

Here the first test (Lamp-Test), clocking in: 10101010 10101010 10101010 10101010 10101010. These are the 5 bytes or the 40 Row-bits. I managed to design the layout with only 5 wire-bridges, on a single sided PCB, see pictures next:

First test :)Resistors function as wire-bridgesAll Rows of displays interconnected

Here few pictures of the first (beta) version. This is one way to build the hardware (pictures taken with a Philips webCAM)

The next task is writing the complete software. I wrote a routine which does the multiplexing of the display, it reads an SRAM buffer of 40 bytes the whole time, with this buffer I can setup a Menu with submenu's. In the submenus I have to implement all kinds of features, like: all scrolling directions, scrolling speeds, mirrored image, inverted (negative) image, flipped (upside down) image, text-edit, etc.

On the next page you will find information on how to use the UART (Universal Asynchronous Receiver and Transmitter) and how to transmit data from a PC to an AT90S2313.

Using the UART for receiving messages from the PC:

With the UART (Universal Asynchronous Receiver and Transmitter) of the AT90S2313, you are able to receive and transmit serial data via RS232 or COM ports of PC's. In this LED sign project I will only use the data reception feature. To receive data from i.e. a PC, you need a level converter, like a MAX232, or use standard components and make your own level converter (diagrams can be found via Google). A level converter is needed because the COMmunication port of a PC switches the data between approx. -9.23 to 9.23 Volt (I measured these levels, can vari a bit from PC to PC), -9.23 Volt corresponds with a logical '0' (lo), 9.23 Volt corresponds with a logical '1' (hi), both on TTL level of 5 Volt, so can be connected directly to the i/o's of an AVR. The MAX232 can convert at a maximum speed of 120kbit/sec. Here a very simple diagram of an RS232 converter (receive data only):

RS232 level converter MAX232 for receiving message-data for the Moving Message Sign.

Not much components needed, only five electrolytical capacitors (elco's) and a MAX232. For the PC cable use shielded data cable. The UART (software) setup for the AVR is also very simple. First set the baudrate and enable the UART, like this:

sbi UCR, RXEN ;enable UART (receive mode)
ldi temp, 25 ;set baud rate at 9600
out UBRR, temp

Now the UART has been setup, now you can use the data in the software. The number 25 must be calculated, with the following formula (explained in detail in the AT90S2313 datasheet):

UBRR = XTAL / (baudrate*16) - 1
UBRR = 4.000.000 / (9600*16) - 1
UBRR = (4.000.000 / 153600) - 1 = (approx. round number down) 26 - 1 = 25.

Another way of calculating this number is, let the assembler do it for you. Simply put the numbers in the code, as follows:

ldi temp, 4000000/(9600*16)-1 ;set baudrate

Now the assembler does the calculation. Much easier to change the baudrate. You can even use variables 'BAUD' and 'XTAL', like this:

.equ BAUD = 9600
.equ XTAL = 4000000

ldi temp, XTAL/(BAUD*16)-1 ;set baudrate

This way you can change the parameters of the program from a list with variables. The advantage is when you have a huge program, you don't have to fill in each parameter by hand, change just one variable and all others change with that variable.
Next a low-cost UART interface for RS232 with low-cost standard components:

RS232 level converter with standard low-cost components for receiving message-data for the Moving Message Sign.

Using the TPIC6C595 power logic shiftregister as Columns driver.

The TPIC6C595 is an 8-bit shiftregister which contains power DMOSFET's in the output stages. Each output can sink up to 100 mA continue or 250 mA pulsed. The FET outputs are Drains, and can operate at the maximum voltage of 33 V. A 74HC595 can only source up to 25 mA (74HC595 outputs will saturate), when multiplexing the LED dotmatrix displays, at 25 mA max. current and a PWM style signal at a frequency of about 100 Hz, the dots will only consume a few percent of their then needed current, thus won't lit up fully, so you need a stronger power source, the TPIC6C595. You also need good Row driver FET's, more about these later. Here a test circuit:

BC327-25's as Rows drivers (sourcing current), TPIC6C595 as current sinking device for the Columns

The TPIC6C595 under test, using an AT90S2313 and BC327-25's as Row drivers.

For one or two LED dotmatrix displays you can use common transistors, like a low-cost BC327-25. Each BC327-25 provides current for each Row of the dotmatrix display, thus acting as a current source. The TPIC6C595 acts as a current sink device (Sources inside the chip connected to GND, see diagram in datasheet)

List of Articles
번호 제목 글쓴이 날짜 조회 수

H/W 아이폰 충전 회로 file

  • eastsky
  • 2010-10-29
  • 조회 수 26405

iPhone Connector Info (Pin 27) USB Data (+) Pins 25 and 27 may be used in different manner. To force the iPod 5G to charge in any case, when USB Power 5 VDC (pin 23) is fed, 25 must ...

AVR Project UHF FSK PLL RF Module (NR-FPCX) file

  • eastsky
  • 2010-10-20
  • 조회 수 39196

UHF FSK PLL방식 무선 데이터 송/수신 모듈을 이용한 AVR 회로도 및 HEX 파일입니다. 기본적으로 CodeVision 에서 컴파일 한 HEX 이며, 2세트간에 10~20 Byte 이내에 데이터 송수신을 위한 회로 입니다. RF-Module ...

AVR Project Keypad & Encoder file

  • eastsky
  • 2010-10-15
  • 조회 수 30336

74HC138 을 이용한 10 * 8 Keypad 회로 입니다.. Encoder 을 사용할 때 시계방향과 반시계방향을 체크하는 방법입니다.. 여러가지가 있겠지만, 일정 시간 샘플링을 통한 방법이 가장 쉬우면서도 유효하다고 봅니다.

AVR Project JTAGICE mkII 상세 설명서 file [3]

안녕하세요 ⚑ 제가 JTAGICE mkII 상세 설명서를 얻었는데요 이 자료를 함동호님과 회원님들에게 드리려고해요. ★ 앞으로 많은 협조를 ★

H/W 스텝모터회로 - 테스트용 file

전에 스텝모터 테스트용으로 만든 회로 입니다.. 실제로 테스트 해보니 잘 돌기는 하는데... 좀 그러네요 ^^; 학교에서 테스트용으로 사용하면 좋을 듯 합니다.. 덤으로 196 모터 회로... 추가

AVR Project ATtiny26L의 AD 변환과 PWM 출력제어 file

http://www.geocities.jp/kuman2600/k2adc.html출처 : www.ipstack.co.kr 손잡이를 돌리면 모타의 회전이 바뀐다. 커다란 가변권선 저항을 직렬로 넣어 콘트롤하는 일이 있습니다. Tiny26L은 AD변환과 PWM기능이 있으므로, 가변저항으로...

AVR 강좌 AVR 관련 자료 file

http://cafe.daum.net/avrworld압축을 푸시면 아래의 자료가 있습니다.. 1. Atmega128 비트설정.pdf 2. ATMEGA 시리즈 클럭 Securit bits 설정방법.pdf 3. 코드비젼_한글메뉴얼.PDF

AVR Project Atmega16을 이용 74HC595 사용 file

http://scipia.co.kr/index.php?i_div=Its_tech_note&i_no=9이츠임베디드Atmega16을 이용 74HC595(8bit serial-in, serial or parallel-out shift register with output latches; 3-state) 사용기 입니다.. 이 자료는 이츠임베디드에...

AVR Project KLM-162CAN 을 이용한 전광판 file

http://myhome.naver.com/dolmangi/ 다른님이 만드신 전광판인데, 오래되어서 자료링크가 안되네요 ^^:   전광판 Electronic Signboard   많은 분들께서 전광판에 관심을 보여주고 계셔서 게시판을 만들었습니다. 많이 이용해...

AVR Project LED 전광판 file

http://home.wanadoo.nl/electro1/avr/dotmatrix.htm 개발자 사이트 : http://home.wanadoo.nl/electro1/avr/dotmatrix.htm 관련 사이트 : http://www.edaboard.com/ftopic58756-30.html 74H595 Shift Register App : http://www.kronosr...

AVR Project Stepper Motor Controller file

http://www.doc.ic.ac.uk/~ih/doc/stepper/control2/connect.html 새 페이지 2   Stepper Motor Controller Connection Diagrams The wires from the Logic PCB connector to the stepper motor in a TM100 Di...

AVR Project Christmas Tree file

http://www.grantronics.com.au Christmas Tree Here is a fun project to put on your Christmas Tree or in your front window to impress the neighbours. Multi-Coloured Christmas...

AVR Project Mega8 Door Bell file

http://www.microsyl.com 초인종 -줄거리 초인종은 간단해 보이나 그렇지 않다! 펄스폭변조로 정현파를 발생시키는 것은 매우 까다롭다, ATMega8의 발진으로 부터 OC1A를 출력하고 정현파 참조표로 부터 펄스폭이 정의된다. 1.8khz의...

AVR 강좌 Codevision C언어 Manual file

코드비젼 c언어 메뉴얼입니다

AVR 강좌 스텝모터 구동 및 구동회로도 file

전자부품연구원(KETI)에서 만든 기술 자료입니다 .

AVR Tool AVR OrCad9.1 Capture library file

http://www.dr-jekyll.pe.kr라이브러리 파일을 다운로드 받아서 압축을 푼후 capture\library\atmel 폴더에 넣으세요. 그리고 회로를 그릴때 add library해서 그리시면 됩니다. 라이브러리에 포함된 cpu리스트입니다. ATTINY12 ATTI...

AVR Project 12C508 IR Proximity Detector file

http://users.frii.com/dlc/robotics/projects/botproj.htm 적외선 LED와 적외선 리모콘용 수신센서를 이용한 근접센서 프로젝트입니다. 포토센서를 사용하는 방법보다 비교적 먼거리의 물체를 한개의 IR수신 IC로 감지합니다. 첨부된 ...

AVR 강좌 일반, 모터,센스, 전원회로 링크 file

** 예전 땜쟁이가 사는 곳의 링크 입니다 ** 일반회로 http://www.6k2avl.com/k_logic1.htm 모터회로 http://www.6k2avl.com/k_logic2.htm 센스회로 http://www.6k2avl.com/k_logic3.htm 전원회로 http://www.6k2avl.com/k_logic4.htm

AVR Project Led Sign with MMC Memory file

http://www.microsyl.com/     Led Sign with MMC Memory Card   History At the beginning this project was to buy a led sign to interface with my home automatisation network. This automatisation network ...

AVR Project MP3 Player file

http://www.microsyl.com/     MP3 Player History I decided to do this project for several reasons: first I like music, second I have a ton of MP3 and third I wanted to be able to listen those ...