OK Mégsem
Fórum témák

» Több friss téma
Fórum
Keresés
Lapozás: OK   4 / 7
(#) _JANI_ válasza Erick hozzászólására (») Feb 5, 2013
Ráakadtam a wehrlem 58 226 608: Link (57. oldal,) relé blokksémáját. Így kicsit könnyebb lesz...

WEHRLEM_58_2...jpg		    
(#) J-O-E válasza Joseppe210 hozzászólására (») Jan 27, 2013
Elvileg dicsérik az APS-226-ot ez lenne a PS3-ak jobbik tápja. Érdemes újat venni ha nem vagy jártas a kapcsoló üzemű tápegységek világában. 15-26$ között mozog az E-bay-en de itthon is megveheted háromezer-tol.

Ps3Tapegyseg...jpg		    
(#) CIROKL válasza (») Jan 6, 2013
Idézet:
„104 226 felhasználó”

Csak pusztán kiváncsiságból ? ebből mennyi az igazi felhasználó mert rengeteg van olyan aki csak beregisztrált és soha többé be sem jelentkezett, illetve már mondjuk 3-4 éve nem volt itt.
/ Tudom nem ide tartozik de ezeket a rendszerből ki kellene venni ! /
(#) Hp41C válasza havranarpi hozzászólására (») Dec 28, 2012
Szia!
TO-226 toknak néz ki... Ha az, akkor jól van beültetve.
ICSP csatlakozó kiosztásam, a BS250 felé van az 1.láb:
1 - MCLR / Vpp, 2 - Vdd, 3 - Vss, 4 - PGD, 5 - PGC, 6 - AUX
(#) gordonfreemN válasza kaqkk hozzászólására (») Dec 25, 2012
Köszi, egyszer majd lehet kipróbálom, de egyelőre végtelenített forrásból kapom ingyen a 3M-es fóliát. Most van két dobozzal
Bővebben: Link
A hozzászólás módosítva: Dec 25, 2012
(#) aroxol hozzászólása Okt 15, 2012
Sziasztok!

Az Itt: találhato vevöt szeretném egy programba integrálni. Az lenne a problémám hogy C-ben van és asm-be szeretném illeszteni. Fordito ezt dobta, de sehogy nem tudom beilleszteni. Tudna valaki segiteni benne hogy lehetne megoldani? Még a konfig, sem kellene.
  1. _interrupt:
  2.      
  3.     ;vevo.c,42 :: void interrupt (){
  4.     ;vevo.c,43 :: if (INTCON.TMR0IF){                 // időtúllépés-figyelés
  5.     BTFSS       INTCON+0, 2
  6.     GOTO        L_interrupt0
  7.     ;vevo.c,44 :: key_cnt = 0;
  8.     CLRF        _key_cnt+0
  9.     ;vevo.c,45 :: INTCON.TMR0IF = 0;
  10.     BCF         INTCON+0, 2
  11.     ;vevo.c,46 :: }
  12.     L_interrupt0:
  13.     ;vevo.c,47 :: if (PIR1.RCIF){
  14.     BTFSS       PIR1+0, 5
  15.     GOTO        L_interrupt1
  16.     ;vevo.c,48 :: uart_buffer = RCREG;            // törli az RCIF-et, nem kell PIR1.RCIF=0
  17.     MOVF        RCREG+0, 0
  18.     MOVWF       _uart_buffer+0
  19.     ;vevo.c,49 :: rx_flag = 1;
  20.     MOVLW       1
  21.     MOVWF       _rx_flag+0
  22.     ;vevo.c,50 :: }
  23.     L_interrupt1:
  24.     ;vevo.c,51 :: }
  25.     L_end_interrupt:
  26.     L__interrupt11:
  27.     RETFIE      1
  28.     ; end of _interrupt
  29.      
  30.     _main:
  31.      
  32.     ;vevo.c,53 :: void main (){
  33.     ;vevo.c,54 :: OSCCON = 0x72;                      // pdf 32.
  34.     MOVLW       114
  35.     MOVWF       OSCCON+0
  36.     ;vevo.c,55 :: ADCON1 = 0x0F;                      // pdf 226.
  37.     MOVLW       15
  38.     MOVWF       ADCON1+0
  39.     ;vevo.c,56 :: CMCON = 0x07;                       // pdf 235.
  40.     MOVLW       7
  41.     MOVWF       CMCON+0
  42.     ;vevo.c,57 :: TRISA = 0;
  43.     CLRF        TRISA+0
  44.     ;vevo.c,58 :: LATA = 0;
  45.     CLRF        LATA+0
  46.     ;vevo.c,59 :: TRISB = 0;
  47.     CLRF        TRISB+0
  48.     ;vevo.c,60 :: LATB = 0;
  49.     CLRF        LATB+0
  50.     ;vevo.c,61 :: TRISC = 0b10000000;                 // Rx-Tx
  51.     MOVLW       128
  52.     MOVWF       TRISC+0
  53.     ;vevo.c,62 :: LATC = 0;
  54.     CLRF        LATC+0
  55.     ;vevo.c,63 :: PIE1.RCIE = 1;                      // pdf 100.
  56.     BSF         PIE1+0, 5
  57.     ;vevo.c,64 :: INTCON = 0b11100000;                // pdf 95.
  58.     MOVLW       224
  59.     MOVWF       INTCON+0
  60.     ;vevo.c,65 :: T0CON = 0b10001000;                 // pdf 125.
  61.     MOVLW       136
  62.     MOVWF       T0CON+0
  63.     ;vevo.c,67 :: UART1_Init(2400);
  64.     BSF         BAUDCON+0, 3, 0
  65.     MOVLW       3
  66.     MOVWF       SPBRGH+0
  67.     MOVLW       64
  68.     MOVWF       SPBRG+0
  69.     BSF         TXSTA+0, 2, 0
  70.     CALL        _UART1_Init+0, 0
  71.     ;vevo.c,68 :: delay_ms(100);
  72.     MOVLW       2
  73.     MOVWF       R11, 0
  74.     MOVLW       4
  75.     MOVWF       R12, 0
  76.     MOVLW       186
  77.     MOVWF       R13, 0
  78.     L_main2:
  79.     DECFSZ      R13, 1, 1
  80.     BRA         L_main2
  81.     DECFSZ      R12, 1, 1
  82.     BRA         L_main2
  83.     DECFSZ      R11, 1, 1
  84.     BRA         L_main2
  85.     NOP
  86.     ;vevo.c,70 :: while (1){
  87.     L_main3:
  88.     ;vevo.c,71 :: if (rx_flag == 1){
  89.     MOVF        _rx_flag+0, 0
  90.     XORLW       1
  91.     BTFSS       STATUS+0, 2
  92.     GOTO        L_main5
  93.     ;vevo.c,72 :: rx_flag = 0;
  94.     CLRF        _rx_flag+0
  95.     ;vevo.c,73 :: if (key[key_cnt] == uart_buffer){
  96.     MOVLW       _key+0
  97.     ADDWF       _key_cnt+0, 0
  98.     MOVWF       TBLPTRL
  99.     MOVLW       hi_addr(_key+0)
  100.     MOVWF       TBLPTRH
  101.     MOVLW       0
  102.     ADDWFC      TBLPTRH, 1
  103.     MOVLW       higher_addr(_key+0)
  104.     MOVWF       TBLPTRU
  105.     MOVLW       0
  106.     ADDWFC      TBLPTRU, 1
  107.     TBLRD*+
  108.     MOVFF       TABLAT+0, R1
  109.     MOVF        R1, 0
  110.     XORWF       _uart_buffer+0, 0
  111.     BTFSS       STATUS+0, 2
  112.     GOTO        L_main6
  113.     ;vevo.c,74 :: TMR0H = 0xDE;                     // 65535-8535=57000 (egy bájt plussz az időtúllépése, kb. 90us)
  114.     MOVLW       222
  115.     MOVWF       TMR0H+0
  116.     ;vevo.c,75 :: TMR0L = 0xA8;
  117.     MOVLW       168
  118.     MOVWF       TMR0L+0
  119.     ;vevo.c,76 :: key_cnt++;
  120.     INCF        _key_cnt+0, 1
  121.     ;vevo.c,77 :: }
  122.     GOTO        L_main7
  123.     L_main6:
  124.     ;vevo.c,78 :: else {key_cnt == 0;}
  125.     L_main7:
  126.     ;vevo.c,79 :: if (key_cnt == sizeof(key)-1){        // nyitás
  127.     MOVF        _key_cnt+0, 0
  128.     XORLW       14
  129.     BTFSS       STATUS+0, 2
  130.     GOTO        L_main8
  131.     ;vevo.c,80 :: LATB.B0 = 1;
  132.     BSF         LATB+0, 0
  133.     ;vevo.c,81 :: delay_ms(1000);
  134.     MOVLW       11
  135.     MOVWF       R11, 0
  136.     MOVLW       38
  137.     MOVWF       R12, 0
  138.     MOVLW       93
  139.     MOVWF       R13, 0
  140.     L_main9:
  141.     DECFSZ      R13, 1, 1
  142.     BRA         L_main9
  143.     DECFSZ      R12, 1, 1
  144.     BRA         L_main9
  145.     DECFSZ      R11, 1, 1
  146.     BRA         L_main9
  147.     NOP
  148.     NOP
  149.     ;vevo.c,82 :: LATB.B0 = 0;
  150.     BCF         LATB+0, 0
  151.     ;vevo.c,83 :: key_cnt = 0;
  152.     CLRF        _key_cnt+0
  153.     ;vevo.c,84 :: }
  154.     L_main8:
  155.     ;vevo.c,85 :: }
  156.     L_main5:
  157.     ;vevo.c,92 :: }
  158.     GOTO        L_main3
  159.     ;vevo.c,93 :: }
  160.     L_end_main:
  161.     GOTO        $+0
  162.     ; end of _main
(#) kadarist válasza oleg53 hozzászólására (») Okt 1, 2012
Mutatok egy teljesen hiszterézismentes megoldást. Leírás a weboldalon. Bővebben: Link
(#) Hp41C válasza Hp41C hozzászólására (») Szept 28, 2012
Még nyalánkságok:
XC8 / HighTech C:
  1. 2218                           ;main.c: 1846: Month = BCD2BIN(DCF_Month / 8);
  2.   2219  0A1C  0021                      movlb   1       ; select bank1
  3.   2220  0A1D  083E                      movf    _DCF_Month^(0+128),w
  4.   2221  0A1E  0020                      movlb   0       ; select bank0
  5.   2222  0A1F  00ED                      movwf   ??_main
  6.   2223  0A20  36ED                      lsrf    ??_main,f
  7.   2224  0A21  36ED                      lsrf    ??_main,f
  8.   2225  0A22  36ED                      lsrf    ??_main,f
  9.   2226  0A23  086D                      movf    ??_main,w
  10.   2227  0A24  2720  3188                fcall   _BCD2BIN
  11.   2228  0A26  00B3                      movwf   _Month

Ha már a fordító az lsrf utasítást használja, akkor tudhatná, hogy az advanced midrange kontrolleren a WREG címezhető. Nem kellene a ??_main- be menteni (az érték nem kell másutt), majd visszahozni onnan, ráadásul az utolsó léptetés lsrf ??_main,w formában is el lehet végezni.
  1. 843                           ;main.c: 792: Second2 = BCD2BIN(I2CBuffer.bytes.b[1]) << 1;
  2.    844  093E  0020                      movlb   0       ; select bank0
  3.    845  093F  0844                      movf    _I2CBuffer+1,w
  4.    846  0940  2720  3188                fcall   _BCD2BIN
  5.    847  0942  0709                      addwf   9,w
  6.    848  0943  00BC                      movwf   _Second2

Érdekes, itt eszébe jutott az addwf WREG,w megoldás.

A következő stikli viszont "megmagyarázhatatlan" hibás működéshez vezethet:
  1. 4158                           ;main.c: 2480: SoundCounter = Scratch & 0x0F;
  2.   4159  0EA5  087C                      movf    _Scratch,w
  3.   4160  0EA6  0020                      movlb   0       ; select bank0
  4.   4161  0EA7  00BD                      movwf   _SoundCounter
  5.   4162  0EA8  300F                      movlw   15
  6.   4163  0EA9  05BD                      andwf   _SoundCounter,f

A SoundCounter egy többértékű szemafor, amit a megszakítási rutin használ fel. A módosítását un. primitív művelettel kell végeni, aminek lefutását a megszakítás nem tudja elválasztani, felbeszakítani. Ha a nagyrabecsült fordító a következő - szerintem kézenfekvő - módon fordítaná rövidebb is, és primitív művelet is lenne.
  1. 4158                           ;main.c: 2480: SoundCounter = Scratch & 0x0F;
  2.   4159  0EA5  087C                      movf    _Scratch,w
  3.   4160  0EA6  0020                      movlb   0       ; select bank0
  4.                                         andlw   15
  5.   4161  0EA7  00BD                      movwf   _SoundCounter

Már csak 768 utasítás kellene rövidítenem, hogy a program beneférjen a 16F1827 -re. Az adatok már elférnek a 384 byte RAM -ben...
A hozzászólás módosítva: Szept 28, 2012
(#) fobq válasza gaspa hozzászólására (») Aug 27, 2012
Szia, gaspa!
Jelenleg én is építek egy napelemes forgatót. Megtennéd hogy átjössz ebbe a fórumba, lenne néhány kérdésem, mert én is csinálok jelenleg egyet.
(#) e-chipmunk válasza (Felhasználó 13571) hozzászólására (») Aug 3, 2012
Igazság szerint elég nagy kondik, ezért sztem lehet 22µF-os. Arra gyanakszom, hogy a 226-os és a 220-as ugyan az. Nem egy gyártótól van és szerintem a jelölés más, de az érték ugyan az, viszont mérni meg nem tudom. Szerinted??
(#) speed008 válasza e-chipmunk hozzászólására (») Aug 3, 2012
Üdv!
Nem egészen így van ahogyan írtad.
107J=100µF a többi karakter csak tűrés és egyéb fesz infót jelöl.
106D=10uF
226=22uF
220=22pF
100=10pF
Egyébként a Segédprogramok vagy egy nagyon jó számoló ilyen a feladathoz itt
(#) e-chipmunk hozzászólása Aug 3, 2012
Üdv!
Kicsit megakadtam Tantál elektrolit kondi ügyben! VAn egy pár smd tantál elko kondim és nem tudok rájönni, hogy mik a feliratok rajtuk! Az egyiken ez áll: 107J 22f02 Szerintem ez azt jelenti, hogy10*10 a -7.ed F, tehát 1uF, de mi a többi jel?
A másikon ez áll: A106D u13H, ez akkor egy 10µF lenne?
van még, az 226 25V, ez 22uF
és van olyan, hogy 220-10L AN, sztem ez is 22uF, meg van egy olyan, hogy 100-16L B5, sztem ez meg 10uF!?
Kérlek segítsetek! Kerestem már többfele is meg gugliztam is, ezt azt találtam, de nem tudok rájönni!
(#) zoliee hozzászólása Júl 11, 2012
Sziasztok!
Vettem egy ilyen szivattyút, és az lenne a kérdésem, hogy ez az áramláskapcsoló jó lenne-e hozzá? Az írja hogy kínai, de nagyon jó áron van.. Még kérdés: ha 9 méter vízoszlop van egy 160 átmérőjű csőkútban, elvileg amikor elkezdem szivatni, akkor csökken a vízszint 5-6 méter magasra, azt elvileg stabilan tartja, akkor is érdemes beépíteni szárazfutás elleni védelmet?? A csőkút 28.1 méter mély. Volt hogy 6 órát ment a kölcsön szivattyú, egyszer sem csökkent a vízhozama.. Köszi:Zoli
(#) havranarpi hozzászólása Júl 11, 2012
Sziasztok!
az lenne a kérdésem hogyha szeretném megépíteni ezt a kapcsolást: Bővebben: Link akkor kell-e a csőnek fűtés.Ha igen akkor hány volt.Hány mA?
ÉS még az ,hogy mekkorára méretezzem az 1 µF-es kondit.20V-os már elég?
(#) Haliapu válasza erikabanhidi hozzászólására (») Máj 21, 2012
Sziasztok, bocsi, hogy zavarom a vitát, ezt mind értem, amit itt leirtatok, de attól én még nem haladok előre. A dobozomba 2db 15?,os 300W Reflex 8Ohmos van párhuzamosan kötve és az MNC 33355 driver magas ezek előtt pedig egy 2utas 12dB Reflex hang váltó van és védelem semmi. És ebből a dobozból van 4db, és 2-2 db hangfalat, szoktam sorba kötni így lesz 8Ohm és ezeket hajtom az én általam épített 2x500W os N-mos erősítővel. Van a hang láncba egy limiter is de valami miatt a magasak csak ki melegednek a mélyek azok gond nélkül bírják. Szóval ha jól értem az eszme cseréteket akkor újra kell építenem a kereszt váltót is és ebbe a technikába be ültetni a védelmet ? Ha ez így van akkor ebben kérem a segítségeteket. A 300,as reflex adatai 50-2500Hz / Fs=34,8Hz /Vas=226,94 liter / SPL=98,7dB/1W/1m /Qts=0,25 / Qms=5,34 / Qes=0,26 / Pe=300W / Re=5,92 / R=8Ohm az MNC33355 driverröl csak ennyit találtam 8Ohm, 100/200W, 1kHz-16kHz, 100dB, akkor ehhez a párosításhoz kellene keresztváltó és védelem.
(#) rozsascs válasza Marcicerus hozzászólására (») Ápr 4, 2012
Vagy ez egy biztos megoldás és több is összeköthető Bővebben: Link

Vagy nagyobb távolságra kb 100 m-ig ez az extender Bővebben: Link
Persze az is kérdés, hogy mennyire zavarérzékeny a készülék, amit rá akarsz tenni.
(#) Adamyno válasza (Felhasználó 13571) hozzászólására (») Ápr 2, 2012
tehát hogyha 22M-t keresek, akkor 226-os jelölésű kell ?
(#) ZagorNoNF hozzászólása Márc 16, 2012
Udvozletem!

A kerdesem egyszeru es ugy erzem a valasz is. De sehol nem talalok normalis magyarazatot es leirast.

Eppen egy tervezett duplamembranos melyladat keszulok osszerakni. Jonehanyat csinaltam mar, de szakember nem vagyok. Tobbnyire ujraepitek szepitek javitok hangfalakat. Amolyan "szeretem csinalni hobbi".

Jelenleg ket TESLA ARN 226-03 (100%osak) hangsugarzot akarok egy zart dobozba tenni. Mertem is oket, teljesen megegyeznek.

A problema: kulon kulon gyonyoruen szolnak. Parhuzamosan kotve (ugyanolyan hosszu ugyanolyan tipusu vezetekkel), nagyobb hanghullamokra borzasztomod berecsegnek. Halkabban jol szolnak de nyilvan nem susogast akarok hallani majd beloluk.
Sorba kotve megintcsak szepen szolnak de ugy nem akkora a kilengesuk mintha parhuzamba/kulon-kulon neznem, hallgatnam oket. A fo problemam hogy miert recsegnek es mi erre a megoldas?
4Ohmosak. Erositonek egy Abit 5.1 mely kimenetet hasznalom. Wattban nemhinnem hogy sokat az ki.

Eles menetben kapnak egy szinten klasszikus batar meretu tesla hangvaltot.. a probak alatt nem kotottem be, de kizartnak tartok hogy az lenne a baj.

Napkozben elokaparok egy magnot amit anno tesztelesre hasznaltam, es ellenorzom, hogy azzal is recseg-e ha parhuzamba kotom. Addig meg ledolok pihenni. :]

A segitseget elore is nagyon-nagyon koszonom.
(#) Bonca hozzászólása Feb 8, 2012
Sziasztok!
Én már csináltam infra adatátvitelt, ami működik. Adó és vevő oldalon is PIC-et használok. A Sony SIRC protokollt koppintottam le más időzítésekkel.
Adó oldalon egy hatbites azonosítót lehet beállítani DIP kapcsolóval. A program minimális átalakításával jó lehet a helikopterhez.
Az adó kódja:
  1. /*******************************************************************************
  2.   18F2520
  3.  
  4.   RedLink adó TSAL6200
  5.   --------------------
  6.   6 bites azonosító minden eszköznek, melyet az RB2:RB7 porton levő DIP
  7.   kapcsolóval lehet kiválasztani
  8.  
  9.   a digitális jel vivője 40 kHz (25 us), ajánlott kitöltési tényezője 1/3...1/4
  10.  
  11.   saját protokoll a Sony SIRC mintájára:
  12.  
  13.   _|||||||||||||||_____|||||_____||||||||||_____...    ez az adó jele (digitális jel+40 kHz vivő)
  14.     _____________       ___       ________
  15.   _|             |_____|   |_____|        |_____...    ez a vevőből kijövő jel (digitális jel)
  16.  
  17.    |    Start          | 0       |    1         |      logikai jelek időzítései
  18.    |    750      | 250 |250| 250 |  500   | 250 |      us-ban
  19.  
  20.   RB0, RB1 fenntartva az infra adónak és a külső megszakításnak
  21.  
  22. *******************************************************************************/
  23.  
  24. char send_packet_flag;                  // megszakítás-jelző
  25. char car_id;
  26. char i, car_id_cnt;                     // általános változó
  27.  
  28. void interrupt() {
  29.     if(INTCON3.INT1IF) {                // ez indítja az azonosító küldését, amikor a kocsi célba ér
  30.         send_packet_flag = 1;           // megszakítás-jelzés, ezt kérdezgeti le a főfüggvény
  31.         INTCON3.INT1IF = 0;             // megszakítás flag törlése
  32.     }
  33. }
  34.  
  35. void carrier() {                        // ez a 40 kHz-es vivő 1/3...1/4 kitöltési tényezővel
  36.     LATB.B0 = 1;
  37.     delay_us(6);                        // kb. 1/4 kitöltési tényező
  38.     LATB.B0 = 0;
  39.     delay_us(8);                        // 19 us kellene a 25 us-hoz, de a for ciklus
  40. }                                       // miatt ennyire kell csökkenteni
  41.  
  42. void start_signal() {                   // 750 us-os Start jel
  43.     for(i=0; i<30; i++) {carrier();}
  44.     delay_us(250);                      // 250 us szünet
  45. //    delay_ms(300);                      // debug
  46. }
  47.  
  48. void carrier_zeros() {                  // 250 us-os logikai 0
  49.     for(i=0; i<10; i++) {carrier();}
  50.     delay_us(250);                      // 250 us szünet
  51. //    delay_ms(300);
  52. }
  53.  
  54. void carrier_ones() {                   // 500 us-os logikai 1
  55.     for(i=0; i<20; i++) {carrier();}
  56.     delay_us(250);                      // 250 us szünet
  57. //    delay_ms(300);
  58.  
  59. }
  60. void send_packet() {                    // MSB...LSB
  61.     for(car_id_cnt=2; car_id_cnt<8; car_id_cnt++) {
  62.         car_id = PORTB & 0b11111100;
  63.         car_id >>= car_id_cnt;
  64.         car_id &= 0b00000001;
  65.         if(car_id==1) {carrier_ones();}
  66.         else {carrier_zeros();}
  67.     }
  68. }
  69.  
  70. void main() {
  71.     OSCCON = 0x62;                      // pdf 32.
  72.     ADCON1 = 0x0F;                      // pdf 226.
  73.     CMCON = 0x07;                       // pdf 235.
  74.     TRISB = 0b11111110;
  75.     LATB = 0;
  76.     TRISC = 0;
  77.     LATC = 0;
  78.     INTCON = 0b11000000;                // pdf 95.
  79.     INTCON2 = 0b00000000;               // pdf 96.
  80.     INTCON3 = 0b00001000;               // pdf 97.
  81.    
  82.     while(1) {
  83.         if(send_packet_flag) {          // ha külső megszakítás érkezett,
  84.             start_signal();             // jöhet a Start jel és a
  85.             send_packet();              // RedLink csomag, majd
  86.             send_packet_flag = 0;       // a megszakítás-jelzés törlése
  87.         }
  88.     }
  89. }


A vevő kódja:
  1. /*******************************************************************************
  2.  18F2520
  3.  
  4.  RedLink vevő TSOP4840
  5.  ---------------------
  6.  a vevő kimenetén invertálva jelenik meg a tiszta digitális jel (Start jel,
  7.  adat bitek), ezért lefutó élre egy külső megszakítás elindítja TMR0, majd
  8.  felfutó élnél a TMR0 +100 érték alapján lehet eldönteni, hogy logikai 0 vagy 1
  9.  érkezett
  10.  
  11.  INT0 lábra jön az infra vevőről a jel
  12.  
  13.  4 MHz órajelnél a TMR0 értéke 1 us-onként nő eggyel
  14.  
  15.  egy lefutó él indítja a Timer0-t, aminek a tartalma a belső oszcillátor/4
  16.  frekvenciával nő, amíg a felfutó él meg nem állítja. Így detektálható a Start
  17.  jel, a logikai 0 és az 1
  18.     _____________       ___       ________
  19.   _|             |_____|   |_____|        |_____...     az adó oldali adat
  20.   _               _____     _____          _____...     a vevő oldali adat
  21.    |_____________|     |___|     |________|
  22.  
  23.    | itt indul a Timer0
  24.                  | itt áll meg
  25.                        | itt megint indul
  26.                            |itt megint megáll
  27.  
  28.  ha bejön a Start jel, megméri a következő 6 jelet, hogy logikai 0 vagy 1
  29.  
  30. *******************************************************************************/
  31.  
  32. char edge_type = 0;                         // 1=felfutó, 0=lefutó él
  33. char start_catched = 0;                     // a Start jel megérkezését mutatja
  34. char car_id = 0;                            // a kocsik hatbites azonosítója
  35. char car_id_cnt = 0;
  36. unsigned int TMR0_value = 0;                // a Timer0 értéke
  37. unsigned int TMR0L_value = 0, TMR0H_value = 0;
  38.  
  39. void interrupt() {
  40.     if(INTCON.INT0IF) {
  41.         if(edge_type == 0) {                   // ha lefutó él jött, ...
  42.             T0CON.TMR0ON = 1;                  // elindítja a Timer0-t
  43.             LATA.B0 = 1;
  44.             edge_type = 1;                     // fel-le futó élek megkülönboztetése
  45.             INTCON2.INTEDG0 = 1;               // élfigyelés átállítása felfutóra, pdf 96.
  46.         }
  47.         else {                                 // ha felfutó él jött, ...
  48.             T0CON.TMR0ON = 0;                  // megállítja a Timer0-t
  49.             TMR0L_value = TMR0L;               // fontos az olvasási sorrend: 1.TMR0H 2.TMR0L
  50.             TMR0H_value = TMR0H;
  51.             TMR0_value = (TMR0H_value << 8) + TMR0L_value; // két nyolcbites változó összefűzése 16 bitessé
  52.             TMR0H = 0;                         // kinullázza a Timer0 tartalmát
  53.             TMR0L = 0;                         // fontos az írás sorrend: 1.TMR0H 2.TMR0L
  54.             LATA.B1 = 1;
  55.             edge_type = 0;
  56.             INTCON2.INTEDG0 = 0;               // élfigyelés átállítása lefutóra, pdf 96.
  57.         }
  58.         INTCON.INT0IF = 0;
  59.     }
  60. }
  61.  
  62. void main() {
  63.     OSCCON = 0x62;                      // pdf 32.
  64.     ADCON1 = 0x0F;                      // pdf 226.
  65.     CMCON = 0x07;                       // pdf 235.
  66.     TRISA = 0;
  67.     LATA = 0;
  68.     TRISB = 0b00000001;                 // INT0-ra kötve az infra vevő adatlába
  69.     LATB = 0;
  70.     TRISC = 0;
  71.     LATC = 0;
  72.  
  73.     INTCON = 0b11010000;                // pdf 95.
  74.     INTCON2 = 0b00000100;               // INTO lefutó élre figyel, pdf 96.
  75.     T0CON = 0b00001000;                 // pdf 125.
  76.     TMR0H = 0;                          // kinullázza a Timer0 tartalmát
  77.     TMR0L = 0;                          // fontos a sorrend: 1.TMR0H 2.TMR0L
  78.  
  79.     while(1) {
  80.         if(TMR0_value>750 && TMR0_value<850) {      // 750 us-os Start jel jött?
  81.             start_catched = 1;                      // ha igen, akkor figyeli a többi jelet is
  82.             car_id = 0;
  83.             car_id_cnt = 0;
  84.             TMR0_value = 0;
  85.             LATA.B2 = 1;
  86.         }
  87.         if(start_catched) {
  88.             if(TMR0_value>250 && TMR0_value<350) {  // 250 us-os logikai 0 jel
  89.                 TMR0_value = 0;
  90.                 car_id <<= 1;
  91.                 car_id &= 0b11111110;
  92.                 car_id_cnt++;
  93.                 LATA.B6 = 1;
  94.             }
  95.             if(TMR0_value>500 && TMR0_value<600) {  // 500 us-os logikai 1 jel
  96.                 TMR0_value = 0;
  97.                 car_id <<= 1;
  98.                 car_id |= 0b00000001;
  99.                 car_id_cnt++;
  100.                 LATA.B7 = 1;
  101.             }
  102.             LATC = car_id;
  103.             if((TMR0_value>0&&TMR0_value<250)||(TMR0_value>350&&TMR0_value<500)||        // érvénytlen impulzus hossz
  104.                 (TMR0_value>600&&TMR0_value<750)||(TMR0_value>850&&TMR0_value<65535)){
  105.                 car_id = 0;
  106.                 car_id_cnt = 0;
  107.                 start_catched = 0;
  108.                 LATA.B3 = 1;
  109.             }
  110.             if(car_id_cnt==6) {       // ha mind a hat bit bejött, (azért hat, mert 1-től indul a számozás, nem 0-tól)
  111.                 LATC = car_id;        // fordított sorrendben jönnek a bitek
  112.                 car_id = 0;
  113.                 car_id_cnt = 0;
  114.                 start_catched = 0;
  115.                 LATA.B5 = 1;
  116.             }
  117.         }
  118.     }
  119. }


Bonca
(#) grobi75 hozzászólása Feb 3, 2012
Üdv !

A következő problémám lenne . Szerintem talán ebbe a témába tartozik a problémám , másra már nem tudok gondolni.
Van immár több mint 1,5 éve egy műholdas előfizetésem amit egy plazma tv-n használok. Eddig tökéletes volt minden.
Kb 1 hónapja a kép ?zajos? . A jelenség olyan , hogy halvány majdnem átlós csíkozás megy folyamatosan a háttérben. Ez a jelenség vagy nagyon sötét vagy nagyon világos képnél felettébb zavaró. Szinte mindent kicseréltem . Van még itthon 3 beltéri mindegyikkel ugyanaz a tünet. Scart és rca kábeleket is cseréltem és a teljes koaxot is akkor is csíkozik. A TV-t ha elkapcsolom a paraboláról más bemenetre HDMI vagy Analóg akkor tökéletes minden. A szerelő szerint valami villamos hálózati gondom van.
Átnéztem a villamos rendszerem , minden jó. A mérőtől egy biztosítékon keresztül jön a 1,5 ?es vezeték 1 kötés van rajt ami forrasztott. Ezen az áramkörön csak a tv és számítógép van használva és még 2 lámpa. Az oszlopon volt egy lazább kötés , de a szerelő megcsinálta .
Az érdekesség az , hogy ezek a zajok este 8 körül megszűnnek !!! Hétvégén is vannak időpontok amikor tökéletes.
Arra gondoltam , hogy megméregetem a feszültséget . Mikor csíkos akkor 226-234 voltot mérek abban a konnektorban. Este mikor tökéletes akkor 218-222 V. De hétvégén mértem 207 Voltot is amikor csíkozott.
Az még érdekes , de lehet hogy csak véletlen , hogy ebben az eltelt 1 hónapban tönkrement a mikro és a mosogatógép is .
Röviden ennyi lenne .
Várom a véleményeket és ötleteket , hogy mi lehet a probléma. Üdv grobi
(#) zolika60 válasza HA3GX hozzászólására (») Jan 21, 2012
A trafó egybe van öntve a gyújtás elektronikával. Nincs ott más.Bővebben: Link
(#) Tetye válasza Zs_21 hozzászólására (») Jan 14, 2012
Heló!
Vehetsz egy ilyet amit jól hűtesz. Ehhez nem nagyon kell rajz, max amit látsz az adatlapon.
Vagy csinálhatsz egy kapcsitápot Lm2576 -al. Ezt pedig így.
(#) Bonca válasza cottitomi hozzászólására (») Jan 12, 2012
Hello!
Kiindulásnak itt egy elgondolás:
  1. unsigned short int TMR0_overflow;
  2.  
  3. void interrupt() {
  4.     if(INTCON.INT0IF) {                 // gombnyomás érkezett
  5.         T0CON.TMR0ON = 1;               // TMR0 elindítása
  6.         TMR0_overflow += 5;             // hozzáadva 5 perc
  7.         LATC.B0 = 1;                    // kimenet bekapcsolása
  8.         INTCO.INT0IF = 0;               // jelzőbit nullázása
  9.     }
  10.     if(INTCON.TMR0IF) {                 // TMR0 FF-ből 00-ba fordult
  11.         TMR0_overflow--;                // letelt egy perc
  12.         INTCON.TMR0IF = 0;              // jelzőbit nullázása
  13.     }
  14. }
  15.  
  16. void main() {
  17.     OSCCON = 0x62;                      // pdf 32.
  18.     ADCON1 = 0x0F;                      // pdf 226.
  19.     CMCON = 0x07;                       // pdf 235.
  20.     TRISB = 0b10000000;                 // B port 0. lába kimenet
  21.     LATB = 0;                           // B port minden lába logikai 0
  22.     TRISC = 0;                          // C port minden lába kimenet
  23.     LATC = 0;                           // C port minden lába logikai 0
  24.     INTCON = 0b11010000;                // pdf 95.
  25.     INTCON2 = 0b00000100;               // INTO lefutó élre figyel, pdf 96.
  26.     T0CON = 0b00000111;                 // 256-os előosztó, felhúzóellenállás, pdf 125.
  27.     TMR0H = 0;                          // kinullázza a Timer0 tartalmát
  28.     TMR0L = 0;                          // fontos a sorrend: 1.TMR0H 2.TMR0L
  29.  
  30.     while(1) {
  31.         if(TMR0_overflow==0) {
  32.             LATC.B0 = 1;                // kimenet kikapcsolása
  33.             T0CON.TMR0ON = 0;           // TMR0 megállítása
  34.         }
  35.     }
  36. }


A lényege, hogy egy 18F2520-as mikrovezérlő 4 MHz-es órajellel megy. A Timer0 értéke 1 us-onként nő eggyel. Ha 16 bites módban számol a Timer0, és 256-os előosztója van, akkor kb. 67 másodpercig lehet vele elszámolni, majd FF-ből átfordul 00-ba. Ez megszakítást generál. Minden ilyen megszakítás csökkenti eggyel a TMR0_overflow változó értékét. Minden gombnyomás növeli a TMR_overflow értékét 5-tel.
Ha pontosan kell az egy perc, akkor a Timer0-t nem nulláról kell indítani, hanem 7 másodpercnyi órajellel fel kell tölteni (pontosan 67.107.840-60.000.000).

Bonca

venti.jpg		    
(#) Inhouse válasza zoltanbraun hozzászólására (») Jan 6, 2012
Ha jól rémlik ez a coder/decoder páros megegyezik a 2262/2272 párossal. Amire figyelni kell, hogy létezik többféle verzióban, van ahol impulzust ad a kimenete, van ahol egy kimenet (majdnem) mindig aktív és csak vaáltja őket.

Üdv
Inhouse
(#) Lamboo hozzászólása Dec 7, 2011
Sziasztok
Megépítettem Ezt a villogót, de akadt vele egy kis gondom. SMD alkatrészekből van, működik is rendesen, egyet kivéve, ha 3Vos gombelemről próbálom, akkor folyamatosan világít, nem pedig villog. Ha nagyobb feszt adok neki akkor megszűnik ez a gond. Valahogy le lehetne vinni ezt a küszöbfeszültséget egy ellenállás cseréjével? Mert mindenképpen szükségem lenne rá, hogy arról az elemről menjen.
(#) imikee10 válasza radaz hozzászólására (») Nov 27, 2011
101=100
334=330000=330 K
226=22000000=22 M
Annyi 0-át kell rakni az szám után ahány az utolsó szám értéke.
(#) radaz válasza zoz11 hozzászólására (») Nov 26, 2011
Hello!
Nekem is az a gyanum, mert a nedv.érzékelő körül van egypár SMD ami gyanus, csak az a baj hogy nem tudom a jelzésekből kivenni az értékeket.Pl. a 101-es=100 om,334=322kom, de a 226-os és a felette levő barna 2Momon sem mutat semmit.Tudnátok segiteni abban hogy melyik oldalon találnák SMD jelzéseket értékekkel? Nekem van egy pár mosógéppanelom de nincs rajtuk ilyen jelzésű, meg ha találnák is, az én potméteres pákámmal át tudnám-e rakni hogy ne haljon meg, vagy csak spéci szerszámmal lehet?
(#) zenetom válasza mazso1988 hozzászólására (») Okt 25, 2011
Ez egy LCD kezelő unit, a "lcd_send_byte(address,n)" eljárással tudsz adatot küldeni az LCD-nek. Jelen esetünkben
  1. lcd_send_byte(1,130);
így kell a 130-at adatként elküldeni.
De ezt a főprogramba kell leírni, ... van főpgrogramod?
Szerk.: itt a kijelző adatlapja: Bővebben: Link
Elvileg vannak benne ékezetes betűk, a betűk mellett a kódjuk szerepel decimálisan:

á: 224
é: 130
í: 225
ó: 226
ő: 237
ü: 129
ű: 150
ú: 227

Á: 234
É: 144
Ö: 153
Ő: 236
Ü: 154
(#) pucuka válasza netnet.hu hozzászólására (») Szept 18, 2011
226 W -os. De talán transzformátor esetleg kisegíthetne, mindössze egy 15 W -os 230/14 V -os kellene. Az mégse egy rezsó.
(#) Crea hozzászólása Aug 26, 2011
Úgy néz ki, hogy a PORTB és PORTA kimenet meghalt rejtélyes okok miatt az LCD-re kötött PIC-ben és ez is okozhatja a hibát, majd hamarosan megpróbálom másképp. Igaz az árnyékregisztereket kellene használni habár az adatkiküldés a sima PORTB címzéssel is megtörténik valószínű a fordító miatt. Találtam erre a típusra egy headert csak az a problémám, hogy CSS és inkább ragaszkodom az C18-hoz. Nem tudom, hogy át lehet-e konvertálni az egyikből a másikba hiba nélkül? Van ötletetek?

a header:
  1. 1 /*
  2.     2  *            file: EA-DOGM_MIO.c
  3.     3  *         version: 2.03
  4.     4  *     description: Multi I/O driver for EA DOGM displays
  5.     5  *                : Uses 8Bit, SPI HW or SPI SW (bitbang)
  6.     6  *     written by : Michael Bradley (mbradley@mculabs.com)
  7.     7  *   contributions: Imaginos (CCS forum), Emil Nad (8Bit testing)
  8.     8  *                  jgschmidt (CCS forum)
  9.     9  *
  10.    10  *   Changelog:
  11.    11  *       04/22/2010 v2.03 Minor update, changed EADOGM_SPI_HW for HW SPI 1 and 2
  12.    12  *                  Added setup_spi() for HW SPI use, and spi_clk_div option
  13.    13  *                  thanks to jgschmidt (ccs forum) for noticing hw setup issues
  14.    14  *       12/03/2009 v2.02 bug fix and printChr change, no user change needed for use
  15.    15  *       11/25/2009 v2.01 Minor changes, replaced some functions with macros
  16.    16  *       09/17/2009 v2.00 Major change, IO is now 8Bit or SPI (hw or sw)
  17.    17  *                  rewrote some defines as related to pins
  18.    18  *       09/15/2009 v1.13 added function eaDogM_WriteIntAtPos()
  19.    19  *                  and eaDogM_WriteStringAtPos()
  20.    20  *                  added some defines to clean source
  21.    21  *       08/28/2009 v1.12 EADOGM_COLSPAN defined internally, allowing for
  22.    22  *                  162 model to position correctly (noted by Imaginos, CCS forum)
  23.    23  *                  Added support for 2nd SPI HW port (suggested by Imaginos, CCS forum)
  24.    24  *                  defined a few more special chr's
  25.    25  *       07/12/2009 v1.11 Fixed #define error surrounding BB SPI ini
  26.    26  *                  added eaDogM_ClearRow(row);
  27.    27  *       07/11/2009 Created/Consolidated this file from my testing sets
  28.    28  *
  29.    29  * Usage:
  30.    30  *   In your source, you need to define which EA DOGM display you are using,
  31.    31  *   there are 3 units supported EADOGM081 , EADOGM162 , EADOGM163 To use
  32.    32  *   define with a 1.
  33.    33  *
  34.    34  * #define EADOGM081 1  // to use MODEL EADOG081
  35.    35  * #define EADOGM162 1  // to use MODEL EADOG162
  36.    36  * #define EADOGM163 1  // to use MODEL EADOG163
  37.    37  * #define EADOGMVDD  5   // 5v LCD Vdd
  38.    38  * //#define EADOGMVDD  3   // 3.3v LCD Vdd
  39.    39  *
  40.    40  *
  41.    41  * // we need to define the IO mode we want, select only one of these, set to 1
  42.    42  * #define EADOGM_SPI_HW  1   // hw spi, uses on chip spi
  43.    43  * #define EADOGM_SPI_HW  2   // hw spi, 2nd on chip spi
  44.    44  * #define EADOGM_SPI_DIV SPI_CLK_DIV_64 // used to slow hw spi clock (you can use other constants)
  45.    45  * #define EADOGM_SPI_SW  1   // sw bit bang, can use any io pins
  46.    46  * #define EADOGM_8BIT    1   // 8 bit data bus
  47.    47  *
  48.    48  * // for 8Bit mode only, we need to define the output port
  49.    49  * // however, this can be our own function if need be.
  50.    50  * // example shows output to port b
  51.    51  * #define EADOGM_8BIT_PORT(d) output_b(d);   // we need to define how the byte goes out
  52.    52  * //#define EADOGM_8BIT_PORT(d) your_func(d);   // we need to define how the byte goes out
  53.    53  *
  54.    54  *
  55.    55  * // we need to define a few pins
  56.    56  * #define EADOGM_PIN_RS  PIN_C1   // RS line, (pin 39 on the LCD)
  57.    57  * #define EADOGM_PIN_CSB PIN_C2   // /CSB line, (pin 38 on the LCD) Req for SPI Opt for 8BIT
  58.    58  *
  59.    59  * // for 8 bit mode, we need to define a few more pins
  60.    60  * #define EADOGM_NOCSB 1         // set to 1 if pin 38 (CSB) on lcd is tied to Vss
  61.    61  * #define EADOGM_PIN_E   PIN_C2   // E (pin 36 on the LCD)
  62.    62  * #define EADOGM_PIN_RW  PIN_C6   // RW (pin 37 on the LCD)
  63.    63  *
  64.    64  * // set these if you are using EADOGM_SPI_SW (bit bang)
  65.    65  * #define EADOGM_SCLK_BB PIN_C3 // Connects to pin 29 on LCD
  66.    66  * #define EADOGM_MOSI_BB PIN_C5 // Connects to pin 28 on LCD
  67.    67  *
  68.    68  *
  69.    69  *
  70.    70  * #include "EA-DOGM_MIO.c"
  71.    71  *
  72.    72  *    In your main code, do an ini call
  73.    73  * eaDogM_Initialize();
  74.    74  * eaDogM_DisplayOn();
  75.    75  *
  76.    76  *
  77.    77  * Available Functions:
  78.    78  * -------------------------------------------------------------------------------
  79.    79  *    eaDogM_Cls();                 // clears the screen, homes cursor
  80.    80  *    eaDogM_ClearRow(row);         // clears a row (v1.11)
  81.    81  *    eaDogM_CursorOn();            // turns on the cursor
  82.    82  *    eaDogM_CursorOff();           // turns of the cursor
  83.    83  *    eaDogM_DisplayOn();           // turns on display with cursor off
  84.    84  *    eaDogM_DisplayOff();          // turns off display
  85.    85  *    eaDogM_SetPos(row, col);      // sets position row:0-2, col:0-15
  86.    86  *    eaDogM_WriteChr(byte);        // writes a single chr to the display
  87.    87  *    eaDogM_WriteString(char str); // writes a string to the display
  88.    88  *                                  // note: add this line after device selection
  89.    89  *                                  // to do this: eaDogM_WriteString("Constant")
  90.    90  *                                  //   #device PASS_STRINGS=IN_RAM
  91.    91  *
  92.    92  *    // writes a 2 digit integer at row,col set flag = 1 to disable interrupts
  93.    93  *    eaDogM_WriteIntAtPos(row,col,int[,flag])
  94.    94  *
  95.    95  *    // writes a string at row,col set flag = 1 to disable interrupts
  96.    96  *    eaDogM_WriteStringAtPos(row,col,char str[,flag])
  97.    97  *
  98.    98  *    eaDogM_SetContrast(c);      // set contrast 0 to 15
  99.    99  *    eaDogM_DoubleHeight(row);     // turn on double height, row = 0 or 1
  100.   100  *    eaDogM_DoubleHeightOff();     // turn off double height
  101.   101  * -------------------------------------------------------------------------------
  102.   102  *
  103.   103  */
  104.   104
  105.   105
  106.   106
  107.   107 #ifndef EADOGM_SPI
  108.   108    #define EADOGM_SPI 1
  109.   109
  110.   110 // some special symbol chrs defined
  111.   111 #define EADMSYM_DEG     0b11011111     // degree symbol
  112.   112 #define EADMSYM_DARWL   0b11111011     // double <<
  113.   113 #define EADMSYM_DARWR   0b11111100     // double >>
  114.   114 #define EADMSYM_LT      0b00111100     // less than <
  115.   115 #define EADMSYM_GT      0b00111110     // greater than >
  116.   116 #define EADMSYM_OHM     0b00011110     // ohm symbol
  117.   117
  118.   118 // some command defines
  119.   119 #define EADMCMD_CONTRAST 0b0111000      // contrast command (0b0111xxxx)
  120.   120
  121.   121
  122.   122 // we noticed some issues with GLOBAL on pic24 devices
  123.   123 #ifndef GLOBAL
  124.   124   #define GLOBAL INTR_GLOBAL
  125.   125 #endif
  126.   126
  127.   127
  128.   128 // 1x16
  129.   129 #ifdef EADOGM081
  130.   130    #define EADOGM_ROWS 1
  131.   131    #if EADOGMVDD == 5
  132.   132      #define EADOGM_INIT_BIAS_SET 0x1C
  133.   133      #define EADOGM_INIT_POWER_CONTROL 0x51
  134.   134      #define EADOGM_INIT_FOLLOWER_CONTROL 0x6A
  135.   135      #define EADOGM_INIT_CONTRAST_SET 0x74
  136.   136    #else
  137.   137      #define EADOGM_INIT_BIAS_SET 0x14
  138.   138      #define EADOGM_INIT_POWER_CONTROL 0x55
  139.   139      #define EADOGM_INIT_FOLLOWER_CONTROL 0x6D
  140.   140      #define EADOGM_INIT_CONTRAST_SET 0x7C
  141.   141    #endif
  142.   142
  143.   143    #define EADOGM_INIT_FS1 0x31
  144.   144    #define EADOGM_INIT_FS2 0x30
  145.   145    #define EADOGM_INIT_CLEAR_DISPLAY 0x01
  146.   146    #define EADOGM_INIT_ENTRY_MODE 0x06
  147.   147    #define EADOGM_COLSPAN 16
  148.   148 #endif
  149.   149
  150.   150
  151.   151 // 2x16
  152.   152 #ifdef EADOGM162
  153.   153    #define EADOGM_ROWS 2
  154.   154     #if EADOGMVDD == 5
  155.   155      #define EADOGM_INIT_BIAS_SET 0x1C
  156.   156      #define EADOGM_INIT_POWER_CONTROL 0x52
  157.   157      #define EADOGM_INIT_FOLLOWER_CONTROL 0x69
  158.   158      #define EADOGM_INIT_CONTRAST_SET 0x74
  159.   159    #else
  160.   160      #define EADOGM_INIT_BIAS_SET 0x14
  161.   161      #define EADOGM_INIT_POWER_CONTROL 0x55
  162.   162      #define EADOGM_INIT_FOLLOWER_CONTROL 0x6D
  163.   163      #define EADOGM_INIT_CONTRAST_SET 0x78
  164.   164    #endif
  165.   165
  166.   166    #define EADOGM_INIT_FS1 0x39
  167.   167    #define EADOGM_INIT_FS2 0x38
  168.   168    #define EADOGM_INIT_CLEAR_DISPLAY 0x01
  169.   169    #define EADOGM_INIT_ENTRY_MODE 0x06
  170.   170    #define EADOGM_COLSPAN 40  // suggested that this be 40 on model 162
  171.   171 #endif
  172.   172
  173.   173 // 3x16
  174.   174 #ifdef EADOGM163
  175.   175    #define EADOGM_ROWS 3
  176.   176     #if EADOGMVDD == 5
  177.   177      #define EADOGM_INIT_BIAS_SET 0x1D
  178.   178      #define EADOGM_INIT_POWER_CONTROL 0x50
  179.   179      #define EADOGM_INIT_FOLLOWER_CONTROL 0x6C
  180.   180      #define EADOGM_INIT_CONTRAST_SET 0x7C
  181.   181    #else
  182.   182      #define EADOGM_INIT_BIAS_SET 0x15
  183.   183      #define EADOGM_INIT_POWER_CONTROL 0x55
  184.   184      #define EADOGM_INIT_FOLLOWER_CONTROL 0x6E
  185.   185      #define EADOGM_INIT_CONTRAST_SET 0x72
  186.   186    #endif
  187.   187
  188.   188    #define EADOGM_INIT_FS1 0x39
  189.   189    #define EADOGM_INIT_FS2 0x38
  190.   190    #define EADOGM_INIT_CLEAR_DISPLAY 0x01
  191.   191    #define EADOGM_INIT_ENTRY_MODE 0x06
  192.   192    #define EADOGM_COLSPAN 16
  193.   193 #endif
  194.   194
  195.   195
  196.   196 #define EADOGM_CMD_CLR 1
  197.   197 #define EADOGM_CMD_CURSOR_ON     0b00001111
  198.   198 #define EADOGM_CMD_CURSOR_OFF    0b00001100
  199.   199 #define EADOGM_CMD_DISPLAY_ON    0b00001100
  200.   200 #define EADOGM_CMD_DISPLAY_OFF   0b00001000
  201.   201 #define EADOGM_CMD_DDRAM_ADDR    0b10000000
  202.   202 #define EADOGM_CMD_CGRAM_ADDR    0b01000000
  203.   203 #define EADOGM_CMD_SELECT_R0     0b00011000
  204.   204 #define EADOGM_CMD_SELECT_R1     0b00010000
  205.   205 #define EADOGM_CMD_SET_TABLE2    0b00101010
  206.   206
  207.   207
  208.   208 // spi hw clock div, v2.03 fix
  209.   209 #ifndef EADOGM_SPI_DIV
  210.   210    #define EADOGM_SPI_DIV SPI_CLK_DIV_4
  211.   211 #endif
  212.   212
  213.   213
  214.   214
  215.   215 // sw spi emulation routine (bit bang)
  216.   216 #ifdef EADOGM_SPI_SW
  217.   217    #ifndef EADOGM_SCLK_BB
  218.   218      #define EADOGM_SCLK_BB PIN_C3
  219.   219    #endif
  220.   220    #ifndef EADOGM_MOSI_BB
  221.   221      #define EADOGM_MOSI_BB PIN_C5
  222.   222    #endif
  223.   223
  224.   224
  225.   225 void eaDogM_iniSPI_BB(void)
  226.   226 {
  227.   227    output_drive(EADOGM_SCLK_BB);
  228.   228    output_drive(EADOGM_MOSI_BB);
  229.   229    output_low(EADOGM_SCLK_BB);
  230.   230    output_low(EADOGM_MOSI_BB);
  231.   231 }
  232.   232
  233.   233 void eaDogM_spiWrite_BB(int8 regData)
  234.   234 {
  235.   235
  236.   236   int1 bitOut;
  237.   237   int8 SPICount;                               // Counter used to clock out the data
  238.   238   int8 SPIData;                                // Define a data structure for the SPI data.
  239.   239
  240.   240   output_low(EADOGM_SCLK_BB);                         // and CK low
  241.   241
  242.   242   SPIData = regData;
  243.   243   for (SPICount = 0; SPICount < 8; SPICount++) // Prepare to clock out the Address byte
  244.   244     {
  245.   245     bitOut = bit_test(SPIData,7);
  246.   246     output_bit(EADOGM_MOSI_BB,bitOut);
  247.   247     output_high(EADOGM_SCLK_BB);                      // Toggle the clock line
  248.   248     //delay_us(10);
  249.   249     output_low(EADOGM_SCLK_BB);
  250.   250     //delay_us(10);
  251.   251     SPIData = SPIData << 1;                    // Rotate to get the next bit
  252.   252     }                                          // and loop back to send the next bit
  253.   253
  254.   254   output_low(EADOGM_MOSI_BB);
  255.   255 }
  256.   256
  257.   257 // wrapper for sw spi calls in main program
  258.   258 // v2.01 moved to macro define
  259.   259 #define eaDogM_outSPI(c) eaDogM_spiWrite_BB(c)
  260.   260 #endif
  261.   261
  262.   262 // wrapper for hw spi calls in main program
  263.   263 // v2.01 moved to a macro define
  264.   264 #if EADOGM_SPI_HW == 1
  265.   265    #define eaDogM_outSPI(c) spi_write(c)
  266.   266 #endif
  267.   267
  268.   268 // wrapper for hw2 spi calls in main program
  269.   269 // v2.01 moved to a macro define, v2.03 using EADOGM_SPI_HW to test condition
  270.   270 #if EADOGM_SPI_HW == 2
  271.   271    #define eaDogM_outSPI(c) spi_write2(c)
  272.   272 #endif
  273.   273
  274.   274
  275.   275 #ifdef EADOGM_8BIT
  276.   276 void eaDogM_ini8Bit(void)
  277.   277 {
  278.   278 #ifndef EADOGM_NOCSB
  279.   279    output_drive(EADOGM_PIN_CSB);
  280.   280    output_high(EADOGM_PIN_CSB);
  281.   281 #endif
  282.   282    output_drive(EADOGM_PIN_E);
  283.   283    output_drive(EADOGM_PIN_RW);
  284.   284    output_drive(EADOGM_PIN_RS);
  285.   285    output_low(EADOGM_PIN_E);
  286.   286    output_low(EADOGM_PIN_RS);
  287.   287    output_low(EADOGM_PIN_RW);
  288.   288 }
  289.   289 #endif
  290.   290
  291.   291
  292.   292
  293.   293 #ifdef EADOGM_8BIT
  294.   294 // 8bit mode
  295.   295 void eaDogM_WriteChr(char value)
  296.   296 {
  297.   297    output_high(EADOGM_PIN_RS);
  298.   298    output_low(EADOGM_PIN_RW);
  299.   299    output_low(EADOGM_PIN_E);
  300.   300    #ifndef EADOGM_NOCSB
  301.   301      output_low(EADOGM_PIN_CSB);
  302.   302      #endif
  303.   303    output_high(EADOGM_PIN_E);
  304.   304    delay_ms(1);
  305.   305    EADOGM_8BIT_PORT(value);
  306.   306    output_low(EADOGM_PIN_E);
  307.   307    delay_ms(1);
  308.   308    #ifndef EADOGM_NOCSB
  309.   309      output_low(EADOGM_PIN_CSB);
  310.   310      #endif
  311.   311    delay_ms(1);
  312.   312 }
  313.   313
  314.   314 void eaDogM_WriteCommand(int8 cmd)
  315.   315 {
  316.   316    output_low(EADOGM_PIN_RS);
  317.   317    output_low(EADOGM_PIN_RW);
  318.   318    output_low(EADOGM_PIN_E);
  319.   319    #ifndef EADOGM_NOCSB
  320.   320      output_low(EADOGM_PIN_CSB);
  321.   321      #endif
  322.   322    output_high(EADOGM_PIN_E);
  323.   323    delay_ms(1);
  324.   324    EADOGM_8BIT_PORT(cmd);
  325.   325    output_low(EADOGM_PIN_E);
  326.   326    delay_ms(1);
  327.   327    #ifndef EADOGM_NOCSB
  328.   328      output_low(EADOGM_PIN_CSB);
  329.   329      #endif
  330.   330    delay_ms(1);
  331.   331 }
  332.   332 #else
  333.   333 // spi mode
  334.   334 void eaDogM_WriteChr(char value)
  335.   335 {
  336.   336    output_high(EADOGM_PIN_RS);
  337.   337    output_low(EADOGM_PIN_CSB);
  338.   338    eaDogM_outSPI(value);
  339.   339    output_high(EADOGM_PIN_CSB);
  340.   340    delay_ms(1);
  341.   341 }
  342.   342
  343.   343 void eaDogM_WriteCommand(int8 cmd)
  344.   344 {
  345.   345    output_low(EADOGM_PIN_RS);
  346.   346    output_low(EADOGM_PIN_CSB);
  347.   347    eaDogM_outSPI(cmd);
  348.   348    output_high(EADOGM_PIN_CSB);
  349.   349    delay_ms(1);
  350.   350 }
  351.   351 #endif
  352.   352
  353.   353
  354.   354 void eaDogM_Initialize(void)
  355.   355 {
  356.   356
  357.   357 // v2.03 fix
  358.   358 #if EADOGM_SPI_HW  == 1
  359.   359    setup_spi( SPI_MASTER | SPI_H_TO_L | EADOGM_SPI_DIV );
  360.   360 #endif
  361.   361
  362.   362 // v2.03 fix
  363.   363 #if EADOGM_SPI_HW  == 2
  364.   364    setup_spi2( SPI_MASTER | SPI_H_TO_L | EADOGM_SPI_DIV );
  365.   365 #endif
  366.   366
  367.   367 #ifdef EADOGM_SPI_SW
  368.   368    eaDogM_iniSPI_BB();
  369.   369 #endif
  370.   370
  371.   371 #ifdef EADOGM_8BIT
  372.   372    eaDogM_ini8Bit();
  373.   373 #else
  374.   374    output_drive(EADOGM_PIN_CSB);
  375.   375    output_drive(EADOGM_PIN_RS);
  376.   376    output_high(EADOGM_PIN_CSB);
  377.   377    output_high(EADOGM_PIN_RS);
  378.   378 #endif
  379.   379
  380.   380    delay_ms(200);
  381.   381
  382.   382    eaDogM_WriteCommand(EADOGM_INIT_FS1);
  383.   383    eaDogM_WriteCommand(EADOGM_INIT_BIAS_SET);
  384.   384    eaDogM_WriteCommand(EADOGM_INIT_POWER_CONTROL);
  385.   385    eaDogM_WriteCommand(EADOGM_INIT_FOLLOWER_CONTROL);
  386.   386    eaDogM_WriteCommand(EADOGM_INIT_CONTRAST_SET);
  387.   387    eaDogM_WriteCommand(EADOGM_INIT_FS2);
  388.   388    eaDogM_WriteCommand(EADOGM_INIT_CLEAR_DISPLAY);
  389.   389    eaDogM_WriteCommand(EADOGM_INIT_ENTRY_MODE);
  390.   390
  391.   391 }
  392.   392
  393.   393 // sets contrast, call with a value from 0 to 15
  394.   394 // we also mask off upper 4 bits from c
  395.   395 // v2.01 moved to a macro define
  396.   396 #define eaDogM_SetContrast(c) eaDogM_WriteCommand(EADMCMD_CONTRAST + (c & 0b00001111))
  397.   397
  398.   398 // only tested on 3 line display at the moment,
  399.   399 // thus no constants defined. when fully tested, I will define them
  400.   400 void eaDogM_DoubleHeight(int8 row) // row 0 or 1
  401.   401 {
  402.   402    eaDogM_WriteCommand(EADOGM_CMD_SET_TABLE2); // set instruction table 2
  403.   403    if (row == 0) {
  404.   404      eaDogM_WriteCommand(EADOGM_CMD_SELECT_R0); // select row 0
  405.   405      }
  406.   406    if (row == 1) {
  407.   407      eaDogM_WriteCommand(EADOGM_CMD_SELECT_R1); // select row 1
  408.   408      }
  409.   409    eaDogM_WriteCommand(0b00101100); // turns on double line mode
  410.   410                                     // and set instruction table back to 0
  411.   411 }
  412.   412
  413.   413 // v2.01 moved functions to macros
  414.   414 #define eaDogM_DoubleHeightOff() eaDogM_WriteCommand(0b00101000)
  415.   415 #define eaDogM_Cls()             eaDogM_WriteCommand(EADOGM_CMD_CLR)
  416.   416 #define eaDogM_CursorOn()        eaDogM_WriteCommand(EADOGM_CMD_CURSOR_ON)
  417.   417 #define eaDogM_CursorOff()       eaDogM_WriteCommand(EADOGM_CMD_CURSOR_OFF)
  418.   418 #define eaDogM_DisplayOn()       eaDogM_WriteCommand(EADOGM_CMD_DISPLAY_ON)
  419.   419 #define eaDogM_DisplayOff()      eaDogM_WriteCommand(EADOGM_CMD_DISPLAY_OFF)
  420.   420
  421.   421
  422.   422 void eaDogM_SetPos(int8 r, int8 c)
  423.   423 {
  424.   424    int8 cmdPos;
  425.   425    cmdPos = EADOGM_CMD_DDRAM_ADDR + (r * EADOGM_COLSPAN) + c;
  426.   426    eaDogM_WriteCommand(cmdPos);
  427.   427 }
  428.   428
  429.   429 void eaDogM_ClearRow(int8 r)
  430.   430 {
  431.   431    int8 i;
  432.   432    eaDogM_SetPos(r,0);
  433.   433    for(i=0; i<EADOGM_COLSPAN; i++) {
  434.   434      eaDogM_WriteChr(' ');
  435.   435    }
  436.   436 }
  437.   437
  438.   438 void eaDogM_WriteString(char *strPtr)
  439.   439 {
  440.   440    printf(eaDogM_WriteChr,"%s",strPtr);
  441.   441 }
  442.   442
  443.   443
  444.   444 // Optional DisGIE, set to 1 to disable interrupts
  445.   445 // v1.4 -- provided by Imaginos
  446.   446 void eaDogM_WriteStringAtPos(int8 r, int8 c, char *strPtr, int1 DisGIE=0)
  447.   447 {
  448.   448    if (DisGIE) {
  449.   449       disable_interrupts(GLOBAL);
  450.   450       }
  451.   451
  452.   452    eaDogM_WriteCommand((EADOGM_CMD_DDRAM_ADDR + (r * EADOGM_COLSPAN) + c));
  453.   453    printf(eaDogM_WriteChr,"%s",strPtr);
  454.   454
  455.   455    if (DisGIE) {
  456.   456       enable_interrupts(GLOBAL);
  457.   457       }
  458.   458 }
  459.   459
  460.   460 // Optional DisGIE, set to 1 to disable interrupts
  461.   461 // v1.4 -- provided by Imaginos
  462.   462 void eaDogM_WriteIntAtPos(int8 r, int8 c, int8 i, int1 DisGIE=0)
  463.   463 {
  464.   464    if (DisGIE) {
  465.   465       disable_interrupts(GLOBAL);
  466.   466       }
  467.   467
  468.   468    eaDogM_WriteCommand((EADOGM_CMD_DDRAM_ADDR + (r * EADOGM_COLSPAN) + c));
  469.   469
  470.   470    eaDogM_WriteChr(i/10+'0');
  471.   471    eaDogM_WriteChr(i%10+'0');
  472.   472
  473.   473    if (DisGIE) {
  474.   474       enable_interrupts(GLOBAL);
  475.   475       }
  476.   476 }
  477.   477
  478.   478 // this writes a byte to the internal CGRAM (v2.02)
  479.   479 // format for ndx: 00CCCRRR = CCC = character 0 to 7, RRR = row 0 to 7
  480.   480 void eaDogM_WriteByteToCGRAM(char ndx, char data)
  481.   481 {
  482.   482    unsigned int cmd;
  483.   483
  484.   484    cmd = ndx & 0b00111111; // mask off upper to bits
  485.   485    cmd = cmd | EADOGM_CMD_CGRAM_ADDR; // set bit cmd bits
  486.   486
  487.   487    eaDogM_WriteCommand(cmd);
  488.   488    eaDogM_WriteChr(data);
  489.   489
  490.   490    // this is done to make sure we are back in data mode
  491.   491    eaDogM_SetPos(0,0);
  492.   492 }
  493.   493
  494.   494
  495.   495 #endif
  496.   496
Következő: »»   4 / 7
Bejelentkezés

Belépés
Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem