Teade

Collapse

Foorumi reeglid.

Foorumi reeglistik on uuendatud. Palume tutvuda ja arvesse võtta.
See more
See less

MSP430 prograMMeerimine

Collapse
X
 
  • Filter
  • Kellaaeg
  • Show
Clear All
new posts

    MSP430 prograMMeerimine

    On siin ehk kedagi kes viitsiks koodijupi valmis teha? Olen suht võhik sellel alal.
    Koodis oleks vaja kasutada kahte sisendit ja kolme väljunit.
    Kui ühte väljundisse tuleb signaal siis hakkavad 3 väljundit ette antud tsükliga sisse ja välja lülitama. Väljunditesse panen releed. Peab saama määrata kui kaua on relee sees ja kui kaua on relee väljas kui järgmin relee sisse hakkab tõmbama.

    Teise sisendiga on sama teema. Vahe on ainult selles, et järjekord on erinev.
    msn: pois11@hotmail.com

    #2
    Vs: MSP430 prograMMeerimine

    Esmalt postitatud pois11 poolt Vaata postitust
    Olen suht võhik sellel alal.
    See viga on parandatav
    Koodis oleks vaja kasutada kahte sisendit ja kolme väljundit.
    Kui ühte väljundisse tuleb signaal siis hakkavad 3 väljundit ette antud tsükliga sisse ja välja lülitama.
    Väljunditesse panen releed.
    Mis saab siis kui mõlemad sisendid on sees või väljas?
    Kaks sisendit -neli võimalust.
    Kas ei oleks loogilisem et üks sisend ütleb et tööta ja teine määrab suuna?
    Peab saama määrata kui kaua on relee sees ja kui kaua on relee väljas kui järgmin relee sisse hakkab tõmbama.
    Kuidas toimub see määramine, millised on ajavahed?
    Teise sisendiga on sama teema. Vahe on ainult selles, et järjekord on erinev.
    Seega siis 123 ja 132?
    ___________
    Kas peab kindlasti olema MSP430?

    Comment


      #3
      Vs: MSP430 prograMMeerimine

      Tahtsin just sama küsida, et miks selline kivi valik? Kui täpne ajastus peab olema?

      Comment


        #4
        Vs: MSP430 prograMMeerimine

        Ultraökonoomne mikro ja releed?

        Ja selle releede lülituse juures on ka mitu ajalist võimalust.
        Kas mõlemad võivad olla koos sees?
        Kui suur peab olema mõlemad väljas aeg ümberlülitusel?
        Kas peab kontrollima rakendumist?

        Kas 10 bitti so 1024 ühikut on piisav aja pikkuse seadmise ulatus?
        Siis saaks seda potelt mikrosse lugeda.

        Vastuseid teab poiss11 ja Issand jumal.

        Comment


          #5
          Vs: MSP430 prograMMeerimine

          Kiviks msp430 valisin sellepärast, et säästa energiat. Mõned päevad tagasi võtsin alles pakendist välja ja nüüd oskan juba valmis kirjutatud tarkvara peale laadida
          Mul on nii, et jah piisab ühest sisendist kuhu lasen +3 volti sisse. Sel hetkel siis peaks kivi tööle minema ja hakkama väljundite taga olevaid releesid klõpsima. Teise sisendi võib tõesti jätta valiku / suuna määramiseks. Tõmbama peab üks relee korraga ja ainult ühe tsükli. Ehk kui sisendisse jääb pidev +3 volti ei ketrata tsüklit uuesti. Uuesti korratakse siis kui sisendis kaob +3 volti ära ja tuleb uuesti.

          Ajad ei pea olema nii täpsed võivad 10-20% kõikuda. Olen varem valmis teinud ka exceli tabeli mis mul vaja on. Ühele TÜ töötavale sõbrale näitasin, ütles, et see on nii lihtne asi. Ma ikka ise ei saa mõhkugi aru. Koodi sees mingeid aegu oskaks vast ise muuta ja sättida. Põhi tuuma valmis teha ei oska.
          Siin on exceli fail ka mida mul vaja: http://www.upload.ee/files/4125333/projekt4.xlsx.html
          msn: pois11@hotmail.com

          Comment


            #6
            Vs: MSP430 prograMMeerimine

            Esmalt postitatud pois11 poolt Vaata postitust
            Mõned päevad tagasi võtsin alles pakendist välja ja
            nüüd oskan juba valmis kirjutatud tarkvara peale laadida
            Mis on see valmis kirjutatud tarkvara?
            Kas midagi kõrgkeeles või jupp masinkoodi?

            Comment


              #7
              Vs: MSP430 prograMMeerimine

              Ei ole siis tegijat kes mulle selle valmis kirjutaks? Saan aru, et päike paistab ja ilm on soe. Kui asi on motivatsioonis siis eks mul tuleb see õlleraha välja käia. Tehke oma pakkumine.
              msn: pois11@hotmail.com

              Comment


                #8
                Vs: MSP430 prograMMeerimine

                Esmalt postitatud pois11 poolt Vaata postitust
                Kui asi on motivatsioonis siis eks mul tuleb see õlleraha välja käia.
                intellektuaalne omand ja teadmised+oskused+raisatud aeg maksavad umbes 100...1000 korda rohkem, kui see pakutav pilsneriraha.
                miks väidan, et nii odavalt ei saa? sest tavaliselt kipub nii olema, et klient ise ka ei tea täpselt mida ta tahab ja tegemise käigus selgub muudkui lisaks, et klient soovib veel igatsugu kellasid-vilesid ja pole algse versiooniga rahul ja tegija peab raiskama aega 10 korda rohkem, kui algne umbmäärane ülesanne paika oli pandud.

                omal mul oli veel mingi 10 aastat tagasi kettal IAR msp piraatversioon :P , millega sai isegi LED-ide vilgutamist tehtud. aga enam ei paku huvi TI msp peale tagasi minna ja selleks vajalikke töövahendeid installida, jne.

                Comment


                  #9
                  Vs: MSP430 prograMMeerimine

                  Esmalt postitatud dieter poolt Vaata postitust
                  omal mul oli veel mingi 10 aastat tagasi kettal IAR msp piraatversioon :P , millega sai isegi LED-ide vilgutamist tehtud. aga enam ei paku huvi TI msp peale tagasi minna ja selleks vajalikke töövahendeid installida, jne.
                  Vaatasin natuke ringi, pakuti MSP430 demosid. C. Esimene näide oli IO demo.
                  Oli ka C translaator, paistis vabavarana. Hakkasin laadima aga siis lugesin seda:
                  Selle asemel, et nõu ja abi anda noritakse ja ilgutakse vigade üle.
                  Rääkige asjast ja juhendage mitte ärge kogude poste nilbustega.
                  Foorum on niigi kokku surnud. Praktiliselt igas teemas targutatakse.
                  Samas vastust küsimusele mis keelt mees kasutab pole siiani.
                  Jätsin siis TI translaatori laadimise pooleli ja kustutasin katsetuse.
                  ***
                  Vast on mõistlik siiski rakendada koolitust.
                  Muidugi, kui on õppimisvõimeline objekt. Ja suudab kirjavigu vältida.
                  Translaatorile piisab ühest veast et mitte väljundit anda.
                  Õnneks translaator ütleb kus viga on.
                  Aga mõtlemise vigu ei näita keegi niisama kätte.
                  ___________________
                  Selle ülesande jaoks on siis vaja:
                  1. Lugemine, kaks bitti
                  2. Kirjutus , kolm bitti
                  3. Taimer või tsükkel
                  4. Muutujate tekitamine
                  5. while, if, for
                  6. Massiiv või korduv alamprogrammi kutsumine.

                  Seda kõike annab suures PC-s ka testida ja siis IO mikrole üle viia.

                  Aga see õlle pakkumine on tõeline .....

                  Comment


                    #10
                    Vs: MSP430 prograMMeerimine

                    Esmalt postitatud pois11 poolt Vaata postitust
                    Ühele TÜ töötavale sõbrale näitasin, ütles, et see on nii lihtne asi.
                    Aga miks siis sõbraga kaubale ei saa, kui nii lihtne on ?

                    Comment


                      #11
                      Vs: MSP430 prograMMeerimine

                      Saangi kaubale aga tal on puhkus ja puht inimlikkusest ei hakka peale käima. Ütleme, et see on mul plaan C. Tema seda plaati soovitaski ja lubas koodi ka valmis kirjutada aga hiljem.

                      Plaan A oli saada siit foorumist abi ja tasuta. Kui vaadata teema arengu käiku siis alguses tekkis tunne küll, et saangi abi aga mida edasi seda rohkem kiskus kiiva. Ikka need targutused ja mitte midagi ütlevad postitused/viited. Oleks siis midagi valesti öelnud. Tasuta keegi teha ei taha, õlle raha pakkudes naerdi välja. Lasen siis juba töö kaudu 35€ tunnis asja ära teha. Kuigi mulle tundub, et see kood on sellise raha eesti palju. Ehk plaan A kukkus mul läbi.

                      Plaan B lähen proovin oma õnne hinnavaatluse foorumis.

                      Olen ise ka aktiivselt googlit kasutanud, sest asi pakub vägagi huvi. Siiski kui ei ole sündinud programmeerijaks siis lihtsalt ei oska seda teha. Hetkel suudan kahte erinevat ledi vilkuma panna kui sisendisse signaal tuleb aga see on ka kõik. Kui ma nüüd hammustaks selle läbi kuidas saada erinevaid tsükleid üksteise otsa laduda ja aegu sättida, et see kordama ei hakkaks. Rohkem polegi vaja. Ei peagi olema kaks varianti ühel kivil. Võin ka teha nii, et panen ühe variandi ühele kivile ja teise teisele kivile. Kivi hind ise on olematu.

                      Mul on seda augustiks vaja ja kui ei saa siis ei saa... elu läheb edasi. Niikaua ikka loodan ja ootan, et keegi kes tunneb, et võib kaaskodaniku aidata ja kirjutab mulle selle koodi valmis.
                      viimati muutis kasutaja pois11; 06 m 2014, 12:27.
                      msn: pois11@hotmail.com

                      Comment


                        #12
                        Vs: MSP430 prograMMeerimine

                        Esmalt postitatud pois11 poolt Vaata postitust
                        Hetkel suudan kahte erinevat ledi vilkuma panna kui sisendisse signaal tuleb aga see on ka kõik.
                        Kas sa seda suudad ka kirja panna mis keeles vilgutamine toimub?
                        Või siis näidata oma "vilgutaja" teksti.

                        Ja katsu lõpetada see hala et "ma ei oska programmi kirjutada".
                        _____________________________
                        Kas kolme LEDi ka vilgutada saad?
                        Kas sisendi signaali kontrollida oskad?
                        Aga kahte sisendit?
                        See osa on IO ja on eri protsessoritel erinev.

                        Kui IO osa on olemas ja keel teada siis saab edasi vaadata.

                        Võta isetehtud lahendus ALGplaaniks.

                        Comment


                          #13
                          Vs: MSP430 prograMMeerimine

                          Esmalt postitatud pois11 poolt Vaata postitust
                          Plaan A oli saada siit foorumist abi ja tasuta.
                          Aga miks Sa siis ei lase end aidata ? Esitatud on ju konkreetsed küsimused, et mis keeles oled siiamaani tehtud loomingu seal kirjutanud ja kuidas see tehtu välja näeb ? Vasta neile ja siis ilmselt juhendatakse Sind juba natuke edasi. Tasuta abi ja tasuta täisteenuse soov on kaks eri asja.

                          Comment


                            #14
                            Vs: MSP430 prograMMeerimine

                            Oma 5h tööd seljataga ja sain esimese variandi valmis. Releed klõpsuvad nii nagu peavad ja aegu saan lihtsa vaevaga muuta. Küsin siis nüüd uuesti ilusi ja kenasti! Kas keegi oleks nõus aitama ja ütlema, ette ära tegema? Kuidas ma saaksin teise sisendi tööle või suunda valima panna, et releed hakkaks teises järjekorras tööle? Loomulikult ma olen suht veendunud kui istun veel 5h siis saan ise hakkama aga milleks siis see foorum üldse on?

                            Panen oma koodi kaasa vaatamiseks.



                            Kood:
                            #include <msp430.h>
                            
                            /*
                             * main.c
                             */
                            
                            
                            #define CS_595 BIT3 //P2
                            #define ENABLE BIT2 //P2
                            #define SCL_PIN BIT5 //CLK
                            #define SDA_PIN BIT7  //Data to 595's
                            #define DISABLE_SR P2DIR |= ENABLE; P2OUT |= ENABLE
                            #define ENABLE_SR P2DIR &= ~ENABLE; P2OUT &= ~ENABLE
                            #define SR_DESELECT P2OUT &= ~CS_595 //Select shift register
                            #define SR_SELECT P2OUT |= CS_595 //Deselect shift register
                            #define BUTTON    BIT3
                            
                            
                            #define RELAY_1 BIT1
                            #define RELAY_2    BIT2
                            #define RELAY_3 BIT3
                            #define RELAY_4 BIT4
                            
                            
                            #define TEST_DELAY 500000
                            
                            
                            //Function prototypes
                            void initSPI();
                            void write(char relays);
                            
                            
                            
                            
                            
                            
                            int main(void) {
                                WDTCTL = WDTPW | WDTHOLD;    // Stop watchdog timer
                            
                            
                                //configuration from GRACE
                                BCSCTL2 = SELM_0 + DIVM_0 + DIVS_0;
                                if (CALBC1_16MHZ != 0xFF) {
                                       /* Adjust this accordingly to your VCC rise time */
                                       __delay_cycles(100000);
                            
                            
                                       /* Follow recommended flow. First, clear all DCOx and MODx bits. Then
                                        * apply new RSELx values. Finally, apply new DCOx and MODx bit values.
                                        */
                                       DCOCTL = 0x00;
                                       BCSCTL1 = CALBC1_16MHZ;     /* Set DCO to 16MHz */
                                       DCOCTL = CALDCO_16MHZ;
                                   }
                                BCSCTL1 |= XT2OFF + DIVA_0;
                                BCSCTL3 = XT2S_0 + LFXT1S_2 + XCAP_1;
                                //INTERRUPT ON 1.3 - Pull up resistor enabled
                                P1IE |= BUTTON;
                                P1IFG |= BUTTON;
                                P1REN |= BUTTON;
                                P1OUT |= BUTTON;
                                P1IFG &= ~BUTTON;
                                P1DIR |= BIT0|BIT1|BIT6;
                                P1OUT &= ~(BIT0|BIT1|BIT6);
                            
                            
                                _bis_SR_register(GIE);
                            
                            
                                initSPI();
                                ENABLE_SR;
                                LPM0; //sleep until button press
                                while(1)
                                {
                                    P1OUT |= BIT0;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT0;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(8000000); //half second
                            
                            
                            
                            
                                    P1OUT |= BIT1;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT1;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(8000000); //half second
                            
                            
                            
                            
                                    P1OUT |= BIT6;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT6;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(99999999); //half second
                            
                            
                                    P1OUT |= BIT1;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT1;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(8000000); //half second
                            
                            
                                    P1OUT |= BIT1;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT1;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(8000000); //half second
                            
                            
                                    P1OUT |= BIT1;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT1;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(8000000); //half second
                            
                            
                                    P1OUT |= BIT1;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT1;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(8000000); //half second
                            
                            
                                    P1OUT |= BIT1;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT1;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(8000000); //half second
                            
                            
                                    P1OUT |= BIT1;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT1;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(8000000); //half second
                            
                            
                                    P1OUT |= BIT1;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT1;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(300000000); //half second
                            
                            
                                    P1OUT |= BIT0;
                                    write(RELAY_2);//all on
                                    _delay_cycles(8000000); //half second
                                    P1OUT ^= BIT0;
                                    write(RELAY_2);//turn off 1
                                    _delay_cycles(8000000); //half second
                                    LPM0;
                            
                            
                                }
                            
                            
                            }
                            
                            
                            //Set up USCI_B for SPI
                            void initSPI()
                            {
                                P1DIR |= SCL_PIN|SDA_PIN;
                                P2DIR |= CS_595;
                                SR_DESELECT;
                            
                            
                                P1SEL |= SCL_PIN + SDA_PIN;
                                P1SEL2 |= SCL_PIN + SDA_PIN;
                            
                            
                                _delay_cycles(5000);
                            }
                            
                            
                            /*
                             * Outputs relay settings to booster
                             */
                            void write(char relays) {
                                SR_SELECT;
                            
                            
                                SR_DESELECT;
                            }
                            
                            
                            // Port 1 interrupt service routine
                            #pragma vector=PORT1_VECTOR
                            __interrupt void Port_1(void)
                            {
                              //P1OUT ^= 0x01;                            // P1.0 = toggle
                              P1IFG &= ~BUTTON;
                              LPM0_EXIT;
                            }

                            viimati muutis kasutaja Scott; 07 m 2014, 00:52. Põhjus: kood ka postitusse lisatud
                            msn: pois11@hotmail.com

                            Comment


                              #15
                              Vs: MSP430 prograMMeerimine

                              Esmalt postitatud pois11 poolt Vaata postitust
                              Kuidas ma saaksin teise sisendi tööle või suunda valima panna, et releed hakkaks teises järjekorras tööle? Loomulikult ma olen suht veendunud kui istun veel 5h siis saan ise hakkama aga milleks siis see foorum üldse on?

                              Panen oma koodi kaasa vaatamiseks.
                              http://www.upload.ee/files/4143276/Tootav.txt.html
                              Nii võib kirjutada aga kui teha väike muudatus:
                              See while sisu (ws) viia alamprogrammiks
                              so kirjutada
                              void T1() {
                              ws tekst
                              }

                              Siis kirjutada teine alamprogramm uute aegadega
                              nt T2.

                              Ja while teha nii:
                              while(1){
                              if(nupp(1)==1) T1();
                              if(nupp(2)==1) T2();
                              }

                              nupp() oleks funktsioon mis annab tagasi nupu ehk sisendi seisu

                              int nupp(int n){
                              return Button_n(n); // ????
                              }

                              On mugavam lugeda.
                              Ka selle lülitamise võib teha alamprogrammide jadana.
                              Või for tsüklina mis võtab massiividest andmeid.


                              Siis programmis ei ole arvestatu ühekordset läbijooksu.
                              See tuleks lahendada eraldi. On üsna lihtne. Täpselt nii nagu ise rääkides kirjeldad.
                              Kui eelmine oli nupp oli 1 siis salvesta seis ja oota.
                              Kui eelmine oli nupp()==0 ja nüüd on nupp()==0 siis salvesta seis ja oota.
                              Kui eelmine oli nupp()==0 ja nüüd on nupp()==1 siis tee.

                              Aga milleks on foorum seda võiks arutada.

                              Comment

                              Working...
                              X