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

» Több friss téma
Fórum » MSP430 mikrovezérlők
MSP430 mikrovezérlők
 
Témaindító: gomzito, idő: Ápr 21, 2006
Témakörök:
Lapozás: OK   23 / 139
(#) szitko válasza icserny hozzászólására (») Dec 11, 2011 /
 
Idézet:
„Most akkor mi is a kérdés?”

Szeretnék egy állandót deklarálni, de csak részben állandó, mert külső tényezőtől függ az alapbeállítás. Ha valamiért változna a külső tényező, akkor "újra kéne állítani" az állandót. De ha ilyen bonyolult, lehet, hogy megcsinálom egy egyszerű "int" változóval.
(#) idlob válasza szitko hozzászólására (») Dec 12, 2011 /
 
Az az állandó ami futásidőben nem állandó az nem állandó
Erős egyszerűsítéssel elképzelheted úgy, hogy a #define a fordítás során search & replace szerűen működik, mindenhol ahol az "ertek" szóba botlik, azt kitörli, helyére pedig 30-at ír.
Egyébként a kódodban szintaktikailag hibás, helyesen:
  1. #define ertek 30

de egy íratlan szabály szerint a konstansokat nagybetűvel írjuk így még szebb a:
  1. #define ERTEK 30


Ettől függetlenül neked egy int változóra van szükséged.
(#) moderboy hozzászólása Dec 12, 2011 /
 
Sziasztok!

Úgy látom elég sokan belevettétek magatokat ebbe a dologba, nálam jobban hozzáértőktől kérdezném, hogy a wiki és a blokk séma szerint az 5-ös sorozatban is van spy-bi-wire interfész, akkor ezeket is lehet a launchpaddel programozni? Esetleg tapasztalat ezen a téren?
(#) icserny válasza szitko hozzászólására (») Dec 12, 2011 /
 
Idézet:
„Ha valamiért változna a külső tényező, akkor "újra kéne állítani" az állandót.”
Fordítási időben, amikor a #define direktívák feldolgozása történik nincsenek "külső tényezők", ezért hibás az elképzelés. Az int változó használata a megoldás.
(#) icserny válasza moderboy hozzászólására (») Dec 12, 2011 /
 
Idézet:
„ezeket is lehet a launchpaddel programozni?”
Elvileg igen, de nem tudni, hogy az emulátor firmware nem tartalmaz-e valami szoftveres korlátozást. Ki kell próbálni!
(#) hayes987 válasza icserny hozzászólására (») Dec 12, 2011 /
 
Átkötöttem a ledet, meg kicseréltem az ellenállást, most működik rendesen, minden porton. Nem tudom mi lehetett a baj, lehet hogy valahol nem érintkezett rendesen.

Lenne még két kérdésem a témával kapcsolatban:

Ha a felprogramozott mikrokontrollert kiveszem és belerakom egy led villogó áramkörbe, akkor az áramforrást hogy kössem be?

A másik kérdésem, hogy ugyebár a tápfeszültség usb-ről 3,5 V. De ha mondjuk 12 V-os ledeket szeretnék meghajtani, akkor azt hogy oldjam meg?

Üdv: Hayes
(#) icserny válasza hayes987 hozzászólására (») Dec 12, 2011 /
 
Idézet:
„az áramforrást hogy kössem be?”
Nézd meg a cikk első oldalán a kapcsolási rajzot, valamint a mikrovezérlő adatlapját! A mikrovezérlő VDD és VSS (tápfesz és GND) közé kell egy 100 nF-os kondenzátor!
Idézet:
„ugyebár a tápfeszültség usb-ről 3,5 V”

Nem, az USB-ről +5 V-jön (ami a TP1 ponton elérhető). A Launchpad kártyán van egy kis feszültségesésű stabilizátor, az csinál 3,5 V-ot belőle.

Nagyobb áramú vagy feszültségű LED-eknél minimum egy tranzisztort be kell rakni (bázis és kollektorkörbe soros ellenállással), bár a LED-eknél inkább áramgenerátoros meghajtást kellene használni.
(#) szitko válasza icserny hozzászólására (») Dec 12, 2011 /
 
Köszönöm mindkettőtöknek a választ.
idlob: Az = jelet véletlenül raktam oda, tudom, hogy nemkell, de a nagybetűs dolgot nem tudtam. Köszi.
Volt egy kis időm elolvasni a "define"-vel kapcsolatos szabályokat, és nagyjából világossá vált a dolog.
Elméleti szinten szeretném azt kérdezni, hogy két 2553-ast (vagy az egyik egy kisebb típus, még nem választottam ki) szeretnék összekötni, de az egyik 2553-on lenne még egy HC-05 Bluetooth. Hogy lehetne ezt a legegyszerűbben kivitelezni? Azt még hozzátenném, hogy a két uC között minimális kommunikáció lenne, pl.:egy port állapotváltozását jelezné a másiknak.
(#) mzozo95 hozzászólása Dec 12, 2011 /
 
HI!

Vakaki tud egy működő integer to char/string függvényt?
Az itoa-val már pár órája küzködöm, de sehogy sem akarja elfogadni a fordító, talán nem is használható

Egyébként egy lcd-re szeretném kiírni, hogy egy gomb hányszor lett lenyomva (lcd forrás(ezt átalakítottam 8bit-es vezérlésre))

  1. ....
  2.  char asd;
  3.  char *asde;
  4.  int szam=0;
  5. ...
  6. asde="szoveg";
  7. lcd_puts(asde);
  8. szam=1234;
  9. asde= //itt kellene átalakítani az integert char-á
  10. lcd_puts(asde);
  11. ...


Valaki tudna segíteni? Előre is köszönöm!
Zoltán
(#) moderboy válasza mzozo95 hozzászólására (») Dec 12, 2011 /
 
Megnéztem a forrást és a problémát, ezt használhatod 1 karakterre:
  1. lcd_write('0'+szam,1);


ha a számod 0-9 közötti egész pozitív

Ha több karakteres számot szeretnél kiíratni akkor maradékos osztással fel kell szabdalni, ha érdekel előtúrom azt az eljárást valahonnan.
(#) icserny válasza mzozo95 hozzászólására (») Dec 12, 2011 /
 
Ebben a hozzászólásban mutattam egy függvényt, azt lehetne egyszerűsíteni, mert neked nem kell az előjel kiíratása, sem a decimális jegyek levágása, s előjeles long helyett unsigned int bemeneő adatod van.
(#) icserny hozzászólása Dec 13, 2011 /
 
MSP430ware - egy újabb parasztvakítás?
Megjelent az MSP430ware első (1.00.00.00) kiadása, a telepítője a fenti linkről letölthető (regisztrációhoz és egy formalap kitöltéséhez van kötve). A fő attrakció a Driverlib, ami az MSP430 mikrovezérlők perifériáinka kényelmes kezelését hivatott elősegíteni. Egyelőre azonban csak az MSP4305xxx és 6xxx sorozathoz van kidolgozva. Futólag megnézve én egy kicsit körülményesnek találom a használatát.

A telepítő csomag másik nagy vívmánya, hogy a dokumentáció és az egyébként külön begyűjtendő MSP430 mintaprogramok is benne vannak (vagy letöltési linket tartalmaznak), s ez a rész teljesnek tűnik (tehát az MSP430G2xxx és MSP430FR57xx sorozathoz is hasznos információkat tartalmaz).

A c:/ti könyvtárba szeret települni. Telepítés után a legkülső könyvtárában nyissuk meg az index.html-t (ha az a neve, már nem emlékszem). Ezen kívül a telepítési könyvtárakat is érdemes böngészni, mert Driverlib forrásállományai is benne vannak!
(#) mzozo95 válasza icserny hozzászólására (») Dec 13, 2011 /
 
Köszönöm a segítségeteket!
Icserny, pont ez kell nekem!
(#) moderboy válasza icserny hozzászólására (») Dec 13, 2011 /
 
Én is néztem, hogy úgy volt promózva hogy ebben aztán minden benne lesz, aztán az olcsó kategóriás procikhoz semmi driver nincs
(#) Beachway hozzászólása Dec 14, 2011 /
 
Azt hiszem már kezdem megérteni a programozás alapjait. Sok kis ciklust irkáltam tanulás képen.Itt egy mágnes kapcsolót szimuláló öntartós, ki be gombos verzió.A sikerélményhez hozzá tartozik, hogy saját kútfőből jött.
P1DIR |= BIT0;
P1DIR &= ~BIT1;
P1DIR &= ~BIT2;
P1OUT = 0X00;
while(1) {
while(P1IN & BIT1) {
P1OUT = 0X00;
}
while(P1IN & BIT2) {
P1OUT = 0X01;
}
(#) szitko válasza gyengus hozzászólására (») Dec 15, 2011 /
 
Ma kaptam meg a LaunchPad-ot, de még a "régi" fajtát küdték. De legalább már van kettő, és nem kell cserélgetni a uC-ket. Kérdeztem ,hogy miért nem a nagyobb uC-vel szereltet küldték, az írták, hogy először kiszorják a régieket.
(#) t0bi válasza icserny hozzászólására (») Dec 15, 2011 /
 
Köszönjük a sok infót, még át fogom nézni, ez mire is használható pontosan. A lábkiosztás változása viszont nagyon fontos.
Beleástam magam az MSP430 USI I2C rejtelmeibe, elkészült a Nokia LCD meghajtó tökéletesített verziója. Mellette sikerült a képkonverter is, I2C-n beolvas két fájlt, a két felső négy bitből alakít egy bájtot, amit visszaír I2C-n keresztül a memóriába. Ha valakit érdekelne, (bár bízom benne, hogy nem, ) szívesen fekrakom a kódot, meg a filmet. Az I2C-nek lelke van, az alap forrást (D. Dang) át kellett alakítani, de ekkor sem működött. El kellett találni, hogy legyen az interrupt, hova és milyen késleltetést kell rakni, hogy működjön. Szóval inkább SPI

P1010373.jpg		    
(#) gyengus válasza szitko hozzászólására (») Dec 15, 2011 /
 
Köszi az infót.
Reméltem, hogy már az újat küldik.
Az icserny által belinkelt 43oh cikk hozzászólásai szerint már volt aki az újat kapta.
(#) szitko válasza gyengus hozzászólására (») Dec 15, 2011 /
 
Idézet:
„Az icserny által belinkelt 43oh cikk hozzászólásai szerint már volt aki az újat kapta.”

Ott olvastam Én is.
Amikor először rendeltem a TI-től LauchPad-ot nem volt nekik, és mentették a rendelésem, és most azt a megrendelést hagytam jóvá. Azthittem ennek van köze hozzá, és ezért kérdeztem rá a TI-nél. Sajnos azt nem írták, hogy mikortól küldik az újakat.
(#) gyengus válasza szitko hozzászólására (») Dec 15, 2011 /
 
Értem, köszi.
(#) mzozo95 válasza t0bi hozzászólására (») Dec 17, 2011 /
 
Szia!
Engem érdekelne a kód !
(#) t0bi válasza mzozo95 hozzászólására (») Dec 17, 2011 / 1
 
Szia!
Fölteszem a kódot, nekem szépen működik. Van egy film is róla a "Színes LCD + PIC" topikban, pontosan ezt csinálja. Bővebben: Link
A Nokia LCD Philips tipusu (sárga panel), ha Epson (zöld panel), akkor kicsit át kell írni a kódot.
A memória 24LC512, ebbe 2 kép fér el 12 bites színnel, de ezeket át kell akkor konvertálni. Nagy nehezen írtam erre egy progit, a képeket PICKit2 klónnal égettem be. Ha eredeti 24 bites .bmp fájlt írsz bele, akkor a kód kicsit változik, viszont akkor csak 1 kép fér a memóriába
  1. // I2C  Receiver, Data goes to Nokia LCD
  2. //   PHILIPS driver!!!!
  3.  
  4. //   Memória : 24LC512, I2C interface
  5. //   2 db kép fér bele 12 bites színben
  6. //   1 kép = 132x132x1,5 Byte = 26.136 Byte = 209.088 bit
  7.  
  8.  
  9. #include <msp430g2231.h>
  10.  
  11. char Read_Write = 0x00;                // Kiolvasási cím
  12. union {
  13.   unsigned int Read_Addr;
  14.   struct  {
  15.     unsigned char Read_AddrL;
  16.     unsigned char Read_AddrH;
  17.   };
  18. };
  19. int I2C_State  = 0;                    // State variable
  20. char SLV_data  = 0x00;                 // Memóriából kiolvasott adat
  21. int Transmit = 0;                      // Segédváltozó 0 vagy 1
  22. char Read_Mem = 0;                     // Segédváltozó 0 vagy 1
  23.  
  24. //*******************************************************
  25. //          GPIO Definitions
  26. //*******************************************************
  27. #define LCD_CS_PIN    BIT1
  28. #define LCD_SCK_PIN   BIT2
  29. #define LCD_DIO_PIN   BIT4
  30. #define LCD_RES_PIN   BIT5
  31.  
  32. #define LCD_RES_PORT  P1OUT
  33. #define LCD_CS_PORT   P1OUT
  34. #define LCD_DIO_PORT  P1OUT
  35. #define LCD_SCK_PORT  P1OUT
  36.  
  37. //*******************************************************
  38. //          Color Definitions
  39. //*******************************************************
  40. #define BLACK       0x000
  41. #define WHITE       0xFFF
  42. #define BLUE        0xF00
  43. #define GREEN       0x0F0
  44. #define RED         0x00F
  45. #define MAGENTA     0xF0F
  46. #define YELLOW      0x0FF
  47. #define CYAN        0xFF0
  48.  
  49. //*******************************************************
  50. //          PHILIPS Controller Definitions
  51. //*******************************************************
  52. #define NOP        0x00  // nop
  53. #define SWRESET    0x01  // software reset
  54. #define BSTROFF    0x02  // booster voltage OFF
  55. #define BSTRON     0x03  // booster voltage ON
  56. #define RDDIDIF    0x04  // read display identification
  57. #define RDDST      0x09  // read display status
  58. #define SLEEPIN    0x10  // sleep in
  59. #define SLEEPOUT   0x11  // sleep out
  60. #define PTLON      0x12  // partial display mode
  61. #define NORON      0x13  // display normal mode
  62. #define INVOFF     0x20  // inversion OFF
  63. #define INVON      0x21  // inversion ON
  64. #define DALO       0x22  // all pixel OFF
  65. #define DAL        0x23  // all pixel ON
  66. #define SETCON     0x25  // write contrast
  67. #define DISPOFF    0x28  // display OFF
  68. #define DISPON     0x29  // display ON
  69. #define CASET      0x2A  // column address set
  70. #define PASET      0x2B  // page address set
  71. #define RAMWR      0x2C  // memory write
  72. #define RGBSET     0x2D  // colour set
  73. #define PTLAR      0x30  // partial area
  74. #define VSCRDEF    0x33  // vertical scrolling definition
  75. #define TEOFF      0x34  // test mode
  76. #define TEON       0x35  // test mode
  77. #define MADCTL     0x36  // memory access control
  78. #define SEP        0x37  // vertical scrolling start address
  79. #define IDMOFF     0x38  // idle mode OFF
  80. #define IDMON      0x39  // idle mode ON
  81. #define COLMOD     0x3A  // interface pixel format
  82. #define SETVOP     0xB0  // set Vop  
  83. #define BRS        0xB4  // bottom row swap
  84. #define TRS        0xB6  // top row swap
  85. #define DISCTR     0xB9  // display control
  86. #define DOR        0xBA  // data order
  87. #define TCDFE      0xBD  // enable/disable DF temperature compensation
  88. #define TCVOPE     0xBF  // enable/disable Vop temp comp
  89. #define EC         0xC0  // internal or external  oscillator
  90. #define SETMUL     0xC2  // set multiplication factor
  91. #define TCVOPAB    0xC3  // set TCVOP slopes A and B
  92. #define TCVOPCD    0xC4  // set TCVOP slopes c and d
  93. #define TCDF       0xC5  // set divider frequency
  94. #define DF8COLOR   0xC6  // set divider frequency 8-color mode
  95. #define SETBS      0xC7  // set bias system
  96. #define RDTEMP     0xC8  // temperature read back
  97. #define NLI        0xC9  // n-line inversion
  98. #define RDID1      0xDA  // read ID1
  99. #define RDID2      0xDB  // read ID2
  100. #define RDID3      0xDC  // read ID3
  101.  
  102. //*******************************************************
  103. //      Macros
  104. //*******************************************************
  105. #define sbi(var, bit)  (var |= bit)
  106. #define cbi(var, bit)  (var &= ~bit)
  107.  
  108.       //Sends a 9 bit command over SPI to the LCD with
  109.       //the first bit HIGH indicating "command" mode.
  110. void lcd_command(unsigned char data)
  111. {
  112.       char j;
  113.  
  114.       cbi(LCD_CS_PORT, LCD_CS_PIN);      // enable chip, p0.20 goes low
  115.       cbi(LCD_DIO_PORT, LCD_DIO_PIN);    // output low on data out (9th bit low = command), p0.19
  116.  
  117.       cbi(LCD_SCK_PORT, LCD_SCK_PIN);    // enable chip, p0.20 goes low
  118.       sbi(LCD_SCK_PORT, LCD_SCK_PIN);    // enable chip, p0.20 goes high
  119.  
  120.       for (j = 0; j < 8; j++)
  121.       {
  122.       if ((data & 0x80) == 0x80) sbi(LCD_DIO_PORT, LCD_DIO_PIN);
  123.       else                       cbi(LCD_DIO_PORT, LCD_DIO_PIN);
  124.  
  125.       // send clock pulse
  126.       cbi(LCD_SCK_PORT, LCD_SCK_PIN);  
  127.       sbi(LCD_SCK_PORT, LCD_SCK_PIN);    
  128.  
  129.       // left most bit first: LSB
  130.       data <<= 1;
  131.       }
  132.       sbi(LCD_CS_PORT, LCD_CS_PIN);        // disable
  133. }
  134.  
  135.       //Sends a 9 bit command over SPI to the LCD with
  136.       //the first bit LOW indicating "data" mode.
  137. void lcd_data(unsigned char data)
  138. {
  139.       char j;
  140.  
  141.       cbi(LCD_SCK_PORT, LCD_SCK_PIN);      // send clock pulse
  142.       cbi(LCD_CS_PORT, LCD_CS_PIN);        // enable chip, goes low
  143.       sbi(LCD_DIO_PORT, LCD_DIO_PIN);      // output high on data out (9th bit high=data)
  144.  
  145.       cbi(LCD_SCK_PORT, LCD_SCK_PIN);      // send clock pulse
  146.       sbi(LCD_SCK_PORT, LCD_SCK_PIN);
  147.  
  148.       for (j = 0; j < 8; j++)
  149.       {
  150.       if ((data & 0x80) == 0x80) sbi(LCD_DIO_PORT, LCD_DIO_PIN);
  151.       else                       cbi(LCD_DIO_PORT, LCD_DIO_PIN);
  152.  
  153.       cbi(LCD_SCK_PORT, LCD_SCK_PIN);  
  154.       sbi(LCD_SCK_PORT, LCD_SCK_PIN);    
  155.  
  156.       data <<= 1;
  157.       }
  158.       sbi(LCD_CS_PORT, LCD_CS_PIN);        // disable
  159. }
  160.  
  161. //************************************************************************
  162. //************************************************************************
  163.  
  164. int main(void)
  165. {
  166.       WDTCTL = WDTPW + WDTHOLD;            // Letiltjuk a watchdog időzítőt
  167.      
  168.       // Oszcillátorok beállítása
  169.       BCSCTL3 = LFXT1S_2;                  // ACLK forrása VLO (LFXT1Sx: '10')
  170.       IFG1 &= ~OFIFG;                      // Az "oszcillátor hiba" törlése
  171.       DCOCTL = DCO2 | DCO0;                // DCOx = 5; MODx = 0;
  172.       BCSCTL1 = XT2OFF+RSEL3;              // RSELx
  173.       BCSCTL1 |= DIVA_3;                   // ACLK osztója: 8
  174.       BCSCTL2 = SELM_0 +                   // MCLK forrása: DCO
  175.                 DIVM_0 +                   // MLCK osztója: 1
  176.                 DIVS_0;                    // SMCLK osztója: 1  
  177.      
  178.       P1OUT = 0xC0;                        // P1.6 & P1.7 Pullups
  179.       P1REN |= 0xC0;                       // P1.6 & P1.7 Pullups
  180.       P1DIR = 0xFF;                        // Unused pins as outputs
  181.       P2OUT = 0;
  182.       P2DIR = 0xFF;
  183.  
  184.       // I2C beállítása
  185.       USICTL0 = USIPE6+USIPE7+USIMST+USISWRST;// Port & USI mode setup
  186.       USICTL1 = USII2C+USIIE;              // Enable I2C mode & USI interrupt
  187.       USICKCTL = USIDIV_3+USISSEL_2+USICKPL;// Setup USI clocks: SCL = SMCLK/8 (~120kHz)
  188.       USICNT |= USIIFGCC;                  // Disable automatic clear control
  189.       USICTL0 &= ~USISWRST;                // Enable USI
  190.       USICTL1 &= ~USIIFG;                  // Clear pending flag
  191.       _EINT();                             // Interrupt enable
  192.      
  193.       #define COLOR1   RED                 // Szín1 kiválasztása
  194.       #define COLOR2   YELLOW              // Szín2 kiválasztása
  195.       #define COLOR3   GREEN               // Szín3 kiválasztása
  196.       #define COLOR4   BLUE                // Szín4 kiválasztása
  197.       #define COLOR5   CYAN                // Szín5 kiválasztása
  198.       #define COLOR6   MAGENTA             // Szín6 kiválasztása
  199.      
  200. //*****************************************************************************  
  201.       // Reset display
  202.       cbi(LCD_RES_PORT, LCD_RES_PIN);
  203.       __delay_cycles (200000);
  204.      
  205.       sbi(LCD_RES_PORT, LCD_RES_PIN);
  206.       __delay_cycles (2000);
  207.  
  208.       // Sleep out  (command 0x11)
  209.       lcd_command(SLEEPOUT);
  210.    
  211.       // Color Interface Pixel Format  (command 0x3A)
  212.       lcd_command(COLMOD);
  213.       lcd_data(0x03);                    // 0x03 = 12 bits-per-pixel
  214.      
  215.       // Memory access controler  (command 0x36)
  216.       lcd_command(MADCTL);
  217.       lcd_data(0xF8);                    // 0xC0 = mirror x and y, reverse rgb
  218.    
  219.       // Write contrast  (command 0x25)
  220.       lcd_command(SETCON);
  221.       lcd_data(0x48);                    // contrast 0x30  
  222.       __delay_cycles(250000);
  223.  
  224.       // Display On  (command 0x29)
  225.       lcd_command(DISPON);               // display on
  226.  
  227. //******************************************************************************
  228.  
  229.        //LCDClearScreen
  230.        long  i;    // loop counter
  231.        
  232.        // Row address set  (command 0x2B)
  233.        lcd_command(PASET);
  234.        lcd_data(0);
  235.        lcd_data(131);
  236.  
  237.        // Column address set  (command 0x2A)
  238.        lcd_command(CASET);
  239.        lcd_data(0);
  240.        lcd_data(131);
  241.  
  242.   while(1)  // Képek közül az egyik, majd a másik kiválasztása
  243.    {
  244.      if(Read_Mem == 0)
  245.      {
  246.        Read_AddrH = 0x00;
  247.        Read_AddrL = 0x02;
  248.        Read_Mem = 1;
  249.      }
  250.      else
  251.      {
  252.        Read_AddrH = 0x66;
  253.        Read_AddrL = 0x20;
  254.        Read_Mem = 0;
  255.      }
  256.      __delay_cycles(400000);
  257.      
  258.        // set the display memory to COLORs
  259.        lcd_command(RAMWR);
  260.        for (i = 0; i < ((132 * 132) / 2); i++)
  261.        {
  262.        lcd_data((COLOR1 >> 4) & 0xFF);
  263.        lcd_data(((COLOR1 & 0xF) << 4) | ((COLOR1 >> 8) & 0xF));
  264.        lcd_data(COLOR1 & 0xFF);  
  265.        }
  266.  
  267.        // Memory access controler  (command 0x36)
  268.        lcd_command(MADCTL);
  269.        lcd_data(0xD8);       // 0xC0 = mirror x and y, reverse rgb
  270.    
  271.        lcd_command(RAMWR);
  272.        for (i = 0; i < ((132 * 132) / 2); i++)
  273.        {
  274.        lcd_data((COLOR2 >> 4) & 0xFF);
  275.        lcd_data(((COLOR2 & 0xF) << 4) | ((COLOR2 >> 8) & 0xF));
  276.        lcd_data(COLOR2 & 0xFF);  
  277.        }
  278.        
  279.        // Memory access controler  (command 0x36)
  280.        lcd_command(MADCTL);
  281.        lcd_data(0x28);      // 0xC0 = mirror x and y, reverse rgb
  282.    
  283.        lcd_command(RAMWR);
  284.        for (i = 0; i < ((132 * 132) / 2); i++)
  285.        {
  286.        lcd_data((COLOR3 >> 4) & 0xFF);
  287.        lcd_data(((COLOR3 & 0xF) << 4) | ((COLOR3 >> 8) & 0xF));
  288.        lcd_data(COLOR3 & 0xFF);  
  289.        }
  290.  
  291.        // Memory access controler  (command 0x36)
  292.        lcd_command(MADCTL);
  293.        lcd_data(0x58);       // 0xC0 = mirror x and y, reverse rgb
  294.    
  295.        lcd_command(RAMWR);
  296.        for (i = 0; i < ((132 * 132) / 2); i++)
  297.        {
  298.        lcd_data((COLOR4 >> 4) & 0xFF);
  299.        lcd_data(((COLOR4 & 0xF) << 4) | ((COLOR4 >> 8) & 0xF));
  300.        lcd_data(COLOR4 & 0xFF);  
  301.        }
  302.  
  303.        //  *****************************************************************************
  304.        // LCDWrite130x130bmp.c
  305.  
  306.        long    j;    // loop counter
  307.  
  308.        // Memory access controler  (command 0x36)
  309.        lcd_command(MADCTL);
  310.        lcd_data(0xF8);      // 0xC0 = mirror x and y, reverse rgb
  311.      
  312.        // Column address set  (command 0x2A)
  313.        lcd_command(CASET);
  314.        lcd_data(0);
  315.        lcd_data(131);
  316.  
  317.        // Page address set  (command 0x2B)
  318.        lcd_command(PASET);
  319.        lcd_data(0);
  320.        lcd_data(131);
  321.        
  322.        // Read from memory
  323.        lcd_command(RAMWR);
  324.  
  325.        for(j = 0; j < 26136; j++)
  326.        {
  327.        USICTL1 |= USIIFG;            // Set flag and start communication
  328.        lcd_data(SLV_data);
  329.        }  
  330.        Transmit = 0;
  331.      }  
  332.        
  333. }
  334. /******************************************************
  335. // USI interrupt service routine
  336. ******************************************************/
  337. #pragma vector = USI_VECTOR
  338. __interrupt void USI_TXRX (void)
  339. { if (Transmit == 0)
  340.      {
  341.       switch(I2C_State)
  342.         {
  343.      
  344.       case 0: // Generate Start Condition & send Device address to slave
  345.               P1OUT |= 0x01;           // LED on: sequence start
  346.               USISRL = 0x00;           // Generate Start Condition
  347.               USICTL0 |= USIGE+USIOE;
  348.               USICTL0 &= ~USIGE;
  349.               USISRL = 0xA0;           // Transmit Device address, R/W = 0
  350.               USICNT = (USICNT & 0xE0) + 0x08; // Bit counter = 8, start TX         1.Byte
  351.               I2C_State = 2;           // Go to next state: receive (N)Ack
  352.               break;
  353.  
  354.       case 2: // Receive Device Address Ack/Nack bit
  355.               USICTL0 &= ~USIOE;       // SDA = input
  356.               USICNT |= 0x01;          // Bit counter = 1, receive (N)Ack bit
  357.               I2C_State = 4;           // Go to next state: check (N)Ack
  358.               break;
  359.  
  360.       case 4: // Process Device Address Ack/Nack & handle Address_H TX
  361.               USICTL0 |= USIOE;        // SDA = output
  362.               if (USISRL & 0x01)       // If Nack received...
  363.               { // Send stop...
  364.                 USISRL = 0x00;
  365.                 USICNT |=  0x01;       // Bit counter = 1, SCL high, SDA low
  366.                 I2C_State = 18;        // Go to next state: generate Stop
  367.                 P1OUT |= 0x01;         // Turn on LED: error
  368.               }
  369.               else
  370.               { // Ack received, TX Address_H to slave...
  371.                 USISRL = Read_AddrH;         // Address_H byte   (Cs=0x00, T=0x66)  
  372.                 USICNT |=  0x08;       // Bit counter = 8, start TX                  2.Byte
  373.                 I2C_State = 6;         // Go to next state: receive data (N)Ack
  374.                 P1OUT &= ~0x01;        // Turn off LED
  375.               }
  376.               break;
  377.  
  378.       case 6: // Receive Address_H Ack/Nack bit
  379.               USICTL0 &= ~USIOE;       // SDA = input
  380.               USICNT |= 0x01;          // Bit counter = 1, receive (N)Ack bit
  381.               I2C_State = 8;           // Go to next state: check (N)Ack
  382.               break;
  383.  
  384.       case 8: // Process Address_H Ack/Nack & handle Address_L TX
  385.               USICTL0 |= USIOE;
  386.               if (USISRL & 0x01)       // If Nack received...
  387.               { // Send stop...
  388.                 USISRL = 0x00;
  389.                 USICNT |=  0x01;       // Bit counter = 1, SCL high, SDA low
  390.                 I2C_State = 18;        // Go to next state: generate Stop
  391.                 P1OUT |= 0x01;         // Turn on LED: error
  392.               }
  393.               else                     // Ack received
  394.               { // Ack received, TX Address_L to slave...
  395.                 USISRL = Read_AddrL;         // Address_L byte  (Cs=0x02, T=0x20)
  396.                 USICNT |=  0x08;       // Bit counter = 8, start TX                  3.Byte
  397.                 I2C_State = 10;        // Go to next state: receive data (N)Ack
  398.                 P1OUT &= ~0x01;        // Turn off LED
  399.               }
  400.               break;
  401.      
  402.       case 10: // Receive Address_L Ack/Nack bit
  403.               USICTL0 &= ~USIOE;       // SDA = input
  404.               USICNT |= 0x01;          // Bit counter = 1, receive (N)Ack bit
  405.               I2C_State = 16;          // Go to next state: check (N)Ack
  406.               break;
  407.      
  408.  
  409.       case 16: // Process Data_1 Ack/Nack & Data_1 TX
  410.               USICTL0 |= USIOE;
  411.               if (USISRL & 0x01)       // If Nack received...
  412.               P1OUT |= 0x01;         // Turn on LED: error
  413.               else                     // Ack received
  414.               {
  415.               P1OUT &= ~0x01;        // Turn off LED
  416.               }
  417.               // Send stop...
  418.               USISRL = 0x00;
  419.               USICNT |=  0x01;         // Bit counter = 1, SCL high, SDA low
  420.               I2C_State = 18;          // Go to next state: generate Stop
  421.               break;
  422.  
  423.       case 18:// Generate Stop Condition
  424.               USISRL = 0x0FF;          // USISRL = 1 to release SDA
  425.               USICTL0 |= USIGE;        // Transparent latch enabled
  426.               USICTL0 &= ~(USIGE+USIOE);// Latch/SDA output disabled
  427.               I2C_State = 0;           // Reset state machine for next transmission
  428.               LPM0_EXIT;               // Exit active for next transfer
  429.               Transmit = 1;            // Changing to read
  430.               break;
  431.           }
  432.  
  433.         USICTL1 &= ~USIIFG;                  // Clear pending flag
  434.       }
  435.  
  436.   else{
  437.     switch(I2C_State)
  438.         {
  439.       case 0: // Generate Start Condition & send address to slave
  440.               P1OUT |= 0x01;           // LED on: sequence start
  441.               USISRL = 0x00;           // Generate Start Condition...
  442.               USICTL0 |= USIGE+USIOE;
  443.               USICTL0 &= ~USIGE;
  444.               USISRL = 0xA1;           // ... and transmit address, R/W = 1
  445.               USICNT = (USICNT & 0xE0) + 0x08; // Bit counter = 8, TX Address
  446.               I2C_State = 2;           // Go to next state: receive address (N)Ack
  447.               break;
  448.  
  449.       case 2: // Receive Address Ack/Nack bit
  450.               USICTL0 &= ~USIOE;       // SDA = input
  451.               USICNT |= 0x01;          // Bit counter = 1, receive (N)Ack bit
  452.               I2C_State = 4;           // Go to next state: check (N)Ack
  453.               break;
  454.  
  455.       case 4: // Process Address Ack/Nack & handle data RX
  456.               if (USISRL & 0x01)       // If Nack received...
  457.               { // Prep Stop Condition
  458.                 USICTL0 |= USIOE;      // SDA = output
  459.                 USISRL = 0x00;
  460.                 USICNT |=  0x01;       // Bit counter = 1, SCL high, SDA low
  461.                 I2C_State = 14;        // Go to next state: generate Stop
  462.                 P1OUT |= 0x01;         // Turn on LED: error
  463.               }
  464.               else                     // Ack received
  465.               { // Receive Data from slave                                        1. byte
  466.                 USICTL0 &= ~USIOE;     // SDA = input
  467.                 USICNT |=  0x08;       // Bit counter = 8, RX data
  468.                 I2C_State = 10;         // Go to next state: Send NAck
  469.                 P1OUT &= ~0x01;        // LED off
  470.                }
  471.               break;
  472.  
  473.       case 10: // Send Data Nack bit
  474.               SLV_data = USISRL;
  475.               USICTL0 |= USIOE;         // SDA = output
  476.               USISRL = 0xFF;           // Send NAck
  477.               USICNT |= 0x01;          // Bit counter = 1, send (N)Ack bit
  478.               I2C_State = 12;           // Go to next state: prep stop
  479.               break;
  480.              
  481.       case 12: // Prep Stop Condition
  482.               USICTL0 |= USIOE;        // SDA = output
  483.               USISRL = 0x00;
  484.               USICNT |=  0x01;         // Bit counter = 1, SCL high, SDA low
  485.               I2C_State = 14;          // Go to next state: generate Stop
  486.               break;
  487.  
  488.       case 14: // Generate Stop Condition
  489.               USISRL = 0x0FF;          // USISRL = 1 to release SDA
  490.               USICTL0 |= USIGE;        // Transparent latch enabled
  491.               USICTL0 &= ~(USIGE+USIOE);// Latch/SDA output disabled
  492.               I2C_State = 0;           // Reset state machine for next transmission
  493.               break;
  494.        }
  495.      USICTL1 &= ~USIIFG;                  // Clear pending flag
  496.    }
  497. }
(#) bedoweb hozzászólása Dec 17, 2011 /
 
Sziasztok

20 db párhuzamosan kötött led-et szeretnék launchpad-dal meghajtani. de ugye nem nem világít eléggé. Ha jňl tudom tranzisztorral a legegyszerűbb megoldani. de milyen tranzisztorral és hogyan kell bekötni? lécci vki segítsen!
(#) mzozo95 válasza bedoweb hozzászólására (») Dec 17, 2011 /
 
Szia!

Az msp430 választott kimenetét egy 10kOhm os ellenállással rákötöd egy (pl) bc547 bázisára, és az emittert rákötöd a gnd-re(-), és az ellenállással a +-ra kötött ledek anódját rákötöd a bc547 kollektorára.
Ha az msp kimenetén logikai 1 van, akkor a ledek világítanak, ha 0, akkor nem

segítség: kép

Zoltán
(#) t0bi válasza bedoweb hozzászólására (») Dec 17, 2011 /
 
Ilyen esetben óvatosan bánjunk a tranzisztorokkal, mert könnyen tönkre lehet tenni az MSP430-at!
Először is 20 db LED minimálisan 20x20 mA áramot igényel, ami kb fél Amper, tehát ide már BD tipusu kellene, BC547 kicsi (csak max 100 mA). A BD tranyóknak viszont kicsi az áramerősítési tényezőjük, tehát nagy bázisáram kellene, ami az MSP430-ból jönne. Az MSP430 max kimenő árama csak 2 mA lehet, tehát inkább FET-et kellene használni, pl. IRL530, vagy hasonlót.
(#) bedoweb válasza mzozo95 hozzászólására (») Dec 17, 2011 /
 
köszi a segítséget
(#) Beachway hozzászólása Dec 19, 2011 /
 
Sziasztok!
Segítséget szeretnék kérni ismét.Megírtam életem első programját tanulás céljából.Persze valami értelmes dolgot akartam alkotni, ezért egy garázs ajtó nyitó szerkezet vezérlését találtam ki.Így nézne ki a program.

#include "io430.h"
#include "intrinsics.h"

void main(void) {
WDTCTL = WDTPW + WDTHOLD; //Letiltjuk a watchdog időzítőt
P1DIR &= ~BIT4; //nyitás nyomógomb
P1DIR &= ~BIT3; //nyitás végállás
P1DIR &= ~BIT2; //zárás nyomógomb
P1DIR &= ~BIT5; //zárás végállás
P1DIR |= BIT0; //nyitás relé
P1DIR |= BIT1; //zárás relé
P1DIR |= BIT6; //világítás
P1DIR |= BIT7; //trafó táplálás motrohoz
while(1) {
while(P1IN & BIT4) { //nyitás feltétele
P1OUT = 0X00;
}
while(P1IN & BIT3) { //nyitás stop feltétele
P1OUT = 0X01; //nyitás relé
P1OUT = 0X80; //motor trafó relé
P1OUT = 0X40; //világítás be
}
while(P1IN & BIT2) { //zárás feltétele
P1OUT = 0X00; //nyitás relé elenged
P1OUT = 0X40; //világítás
}
while(P1IN & BIT5) { //zárás stop feltétele
P1OUT = 0X02; //zárás relé
P1OUT = 0X80; //motor trafó relé
P1OUT = 0X40; //világítás
}
}
}

Ez így működik is ahogy azt elvártam tőle.Viszont ez után jött az ötlet, hogy a világítást az ajtó becsukása után is hagyja égve egy ideig.Így kibővítettem egy újabb ciklussal.
while(P1IN & BIT5) {
P1OUT = 0X40;
__delay_cycles(2000000);
Ez is megy, csak a gond ott kezdődik, hogy mikor a program számol nekem ,hiába is próbálom kinyitni.Ezért kiegészítettem egy continue utasítással, amit feltételhez kötnék.Íme a gondolatom.
while(P1IN & BIT5) {
P1OUT = 0X40;
__delay_cycles(2000000);
if (P1IN & BIT4)
continue;
P1OUT = 0X00;
}
Hát ez sem jó így valamiért.A fordító nem ad semmi hibaüzenetet, de nem működik a ciklus valamiért.Próbáltam a cikluson belül is külön ciklusként futtatni.Ismereteim szerint a continue utasítás átugorja az épp futó ciklust.Jelen esetben a break is megtenné, mert a program legvégén van, de azzal sem ment.Próbáltam a BIT5 -ön negádban is, és lefutó éllel is.A segítséget előre is köszönöm!!
(#) t0bi válasza Beachway hozzászólására (») Dec 19, 2011 /
 
Hasznos kis program
Próbáld meg interrupttal! Ebben az esetben elég egy gomb is a vezérléshez, ha eltárolod, mi volt az utolsó utasítás. Ráadásul elküldheted alukálni is, ha végzett a munkával.
(#) DecebaL válasza Beachway hozzászólására (») Dec 19, 2011 /
 
A __delay_cycles helyett használj egy időzítőt ( pl.: TIMER_A modult )és azzal számold az eltelt időt és akkor fog működni a nyitás zárás.
(#) Beachway válasza DecebaL hozzászólására (») Dec 19, 2011 /
 
sajnos még ezt nem ismerem.Még nagyon kezdő vagyok sajna.Ha tudnál valami konkrét példát írni rá...
Ezekre szükség lehet! - HESTORE.HU

IRL530NPBF
USB-RS232 F
BIT3193-SO
MSP430G2452IN20
MSP430F5510IPT
Következő: »»   23 / 139
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