-         

Seite 1 von 3 123 LetzteLetzte
Ergebnis 1 bis 10 von 23

Thema: Hilfe: Programm übersetzen C -> BasCom [ Oszi Uhr ]

  1. #1
    Benutzer Stammmitglied
    Registriert seit
    09.02.2007
    Alter
    38
    Beiträge
    40

    Hilfe: Programm übersetzen C -> BasCom [ Oszi Uhr ]

    Anzeige

    Hallo,

    ich möchte ein Programm von C nach Bascom übersetzen. Nun bekomme ich schon die ersten Schwierigkeiten.

    1. Wie kann ich folgenden C-Code nach Bascom übersetzen?

    Code:
    #define HIGH           PORTB = 0b11    // oberes Segment
    #define MID             PORTB = 0b10    // mittleres Segment
    #define LOW            PORTB = 0b01    // unteres Segment
    #define ZERO           PORTB = 0b00    // unterste Linie
    Gibt es eine elegantere Lösung als z.B. eine Funktion zu erstellen und dann die entsprechende Option mitzugeben?


    2. Was passiert hier?

    Code:
    unsigned char line[SLOTS] ;
    ...
    
    if(line[dIdx].F6)                          
          {
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
    
            }
    was bedeutet das '.F6' ?

    Werden mit 'MID, LOW, MID, LOW ;' nacheinander die Porteingänge geschalten?


    Danke
    Gruß
    MaXX

  2. #2
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    16.10.2008
    Ort
    Wulferstedt
    Beiträge
    1.042
    Vielleicht kannst Du ja das Projekt kurz beschreiben, damit mans gleich
    ins Bascom schreibt, ohne sich mit C rumzuplagen? VG Micha

  3. #3
    Benutzer Stammmitglied
    Registriert seit
    09.02.2007
    Alter
    38
    Beiträge
    40
    Hallo, JA! Das ist vielleicht das Beste

    Es handelt sich um eine Oszi-Clock die mit einen Kanal und einem Ext.Triggereingang zurecht kommt.

    -> http://www.micro-examples.com/public...-oscillo-clock

    Dort läuft die Uhr allerdings auf einem Pic. Ich möchte die Uhr so in der Art. auf einem kleinen Attiny (12) & Bascom an's laufen bringen.

    Mir ist im C-Code einiges an der Funktionsweise unklar.

    Gruß
    MaXX

  4. #4
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    16.10.2008
    Ort
    Wulferstedt
    Beiträge
    1.042
    Klar! Passt auch besser mit Atmel-Chip. Ne genaure Erklärung wär
    trotzdem nicht schlecht. Bin des Englischen nicht sehr mächtig.
    VG Micha

  5. #5
    Super-Moderator Robotik Visionär Avatar von PicNick
    Registriert seit
    23.11.2004
    Ort
    Wien
    Beiträge
    6.836
    Da Line ja als char (byte) definiert ist, kann "F6" eigentlich nur ein Bit davon sein, vermutlich bit 6
    d.h., wenn dieses bit in char [ idx ] gesetzt ist, durchläuft er
    Portb= &H11
    Portb= &H01.....
    insgesamt 16 mal

    mehr ist aus dem Code-Fragment nicht zu entnehmen.

    Es spricht die Glaskugel:
    vermutlich wird durch Portb die Spannung auf der Y-Achse geregelt,
    also würde der Strahl schnell hin-und-herspringen, also zwei Punkte oder zwei waagrechte Linien am Oszi erzeugen, je nachdem, was sich auf der X.Achse tut

    EDIT: Hab mir den Link angesehen, kenn mich aus. Ist wie vermutet, allerdings erzeugt der Code oben eine Vertikale linie (weil ja X-Achse weiterwandert, dadurch breiter und man sieht dir vertikale Ablenkung
    mfg robert
    Wer glaubt zu wissen, muß wissen, er glaubt.

  6. #6
    Benutzer Stammmitglied
    Registriert seit
    09.02.2007
    Alter
    38
    Beiträge
    40
    hier mal frei übersetzt:

    Für vertikale Segmente die Spannung ein paar Mal hintereinander schnell hoch und runter regeln.
    Für horizontale Segmente die Spannung verändern und so lange halten wie sie gebraucht wird.

    Durch die Verwendung von zwei AVR - Ausgängen und ein R2R Digital / Analog-Wandler erhalten wir bis zu vier verschiedenen Spannungsebenen. Drei Ebenen für die vertikalen Segmente und eine Ebene für die NULL-Linie (Ebene wenn kein Segment gezeichnet wird.)

    Das Problem ist, dass 7-Segment-Ziffern bis zu drei horizontale Linien zur gleichen Zeit beinhalten können (z.B. 2, 3, 8, 9 ..).
    Wir können aber nur eine horizontale Linie in einer Periode zeichnen. Wir benötigen also drei Perioden um eine 7-Segment Ziffer zu zeichnen.

    Durch die Trägheit des Auges ist es möglich eine vollständige 7-Segment-Ziffer.darzustellen.

    Angenommen, wir wollen um 12:34:56 auf dem Bildschirm: darstellen: …
    VG MaXX

  7. #7
    Super-Moderator Robotik Visionär Avatar von PicNick
    Registriert seit
    23.11.2004
    Ort
    Wien
    Beiträge
    6.836
    In der line [slots] sind die 7-Segmente als Bit gesetzt. diese Bits (z.B F6)
    fragt er ab und macht die entsprechenden Sprünge auf dem Oszi.
    mfg robert
    Wer glaubt zu wissen, muß wissen, er glaubt.

  8. #8
    Benutzer Stammmitglied
    Registriert seit
    09.02.2007
    Alter
    38
    Beiträge
    40
    Zitat Zitat von PicNick
    Da Line ja als char (byte) definiert ist, kann "F6" eigentlich nur ein Bit davon sein, vermutlich bit 6
    d.h., wenn dieses bit in char [ idx ] gesetzt ist, durchläuft er
    Portb= &H11
    Portb= &H01.....
    insgesamt 16 mal

    mehr ist aus dem Code-Fragment nicht zu entnehmen.

    Es spricht die Glaskugel:
    vermutlich wird durch Portb die Spannung auf der Y-Achse geregelt,
    also würde der Strahl schnell hin-und-herspringen, also zwei Punkte oder zwei waagrechte Linien am Oszi erzeugen, je nachdem, was sich auf der X.Achse tut
    Danke, jetzt wird es schon etwas klarer.
    Mir ist auch noch unklar wo/wie die einzelnen Segmente definiert werden

    Code:
    /*
     *******************************************************************************
     * PICOCLOCK : PIC Oscilloscope CLOCK
     *******************************************************************************
     *
     * This program shows how to display a digital clock on an oscilloscope
     * with a PIC and only 4 resistors.
     *
     * Circuit schematics :
     *
     * ------------+
     *         RA0 +----------------> to oscilloscope X trigger input
     *             |
     *         RA1 +----------------> pull-up, button to ground : minutes adjustment
     *         RA2 +----------------> pull-up, button to ground : hours adjustment
     *  PIC        |     ____
     *         RB1 +----|____|-----+---------> to oscilloscope Y input
     *             |     680       |
     *             |              +-+
     *             |              | | 330
     *             |              +-+
     *             |     ____      |
     *         RB0 +----|____|-----+
     *             |     680       |
     * ------------+              +-+
     *                            | | 680
     *                            +-+
     *                             |
     *                           -----
     *                            ---   GND
     *                             -
     *
     * Oscilloscope setup :
     * set timebase to 0.1 ms, V/div = 1 V
     * select external trigger.
     *
     * source code for mikro C compiler V7.0.0.3
     * feel free to use this code at your own risks
     * and don't bother me if you get addicted watching this clock.
     *
     * target : PIC16 or PIC18, 16 Mhz crystal
     * HS clock, no watchdog.
     *
     * tested with PIC16F84A and PIC16F877A
     *
     * Author : Bruno Gavand, October 2007
     * see more details on http://www.micro-examples.com/
     *
     *******************************************************************************
     */
    #define TRIGGER         PORTA.F0        // this output is to be connected to oscilloscope trigger input
    #define KEY             PORTA & 0b110   // input keys mask
    #define KEY_MIN_UP      PORTA & 0b010   // minute adjust button
    #define KEY_HH_UP       PORTA & 0b100   // hour adjust button
    
    /*
     * 2 bits R2R DAC gives 4 output levels :
     */
    #define HIGH            PORTB = 0b11    // uper line
    #define MID             PORTB = 0b10    // middle line
    #define LOW             PORTB = 0b01    // lower line
    #define ZERO            PORTB = 0b00    // lowest line
    
    #define MAX_SCALER      15625           // number of timer 0 overflow per second @ 16 Mhz = 16000000 / 4 / 256
    
    #define MAX_DIGIT        6              // number of digits to be displayed
    #define SLOTS           (MAX_DIGIT * 3 + 4)     // number of time slots : 2 for header, 3 per digits, 2 for trailer
    
    /*
     * 10 digits 7 segment encoding + blank
     */
    const unsigned char     septSeg[11] = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x00 } ;
    
    /*
     * slot index for digit start
     */
    const unsigned char     sIdx[] = {1, 4, 8, 11, 15, 18} ;
    
    unsigned char display[MAX_DIGIT] ;      // digit to be displayed
    
    /*
     * time slot encoded line flags :
     * bit 0 is upper line
     * bit 1 is middle line
     * bit 2 is lower line
     * (if no line flag is set, spot is redirected to lowest line)
     * bit 6 is lower vertical bar
     * bit 7 is upper vertical bar
     */
    unsigned char line[SLOTS] ;
    
    unsigned char dIdx = 0 ;        // time slot counter
    unsigned char fIdx = 0 ;        // frame counter
    
    unsigned int scaler = 0 ;       // RTC scaler
    unsigned char   ss = 0, mn = 0, hh = 0 ;        // RTC
    
    /*
     * around 10 micro-second delay
     */
    void    delay10us()
            {
            Delay_us(10) ;
            }
    
    /*
     * ISR
     */
    void    interrupt(void)
            {
            if(INTCON.T0IF)                                         // if timer 0 overflow
                    {
                    scaler++ ;                                      // increment scaler
                    if(scaler > MAX_SCALER)                         // one second has expired ?
                            {
                            scaler = 0 ;                            // clear scaler
                            ss++ ;                                  // next second
                            if(ss == 60)                            // last second in minute ?
                                    {
                                    ss = 0 ;                        // clear second
                                    mn++ ;                          // next minute
                                    if(mn == 60)                    // last minute in hour ?
                                            {
                                            mn = 0 ;                // clear minute
                                            hh++ ;                  // next hour
                                            if(hh == 24)            // last hour in day ?
                                                    {
                                                    hh = 0 ;        // clear hour
                                                    }
                                            }
                                    }
                            }
    
                    if(line[dIdx].F6 && line[dIdx].F7)              // if full vertical bar
                            {
                            LOW, HIGH, LOW, HIGH ;
                            LOW, HIGH, LOW, HIGH ;
                            LOW, HIGH, LOW, HIGH ;
                            LOW, HIGH, LOW, HIGH ;
                            LOW, HIGH, LOW, HIGH ;
                            LOW, HIGH, LOW, HIGH ;
                            LOW, HIGH, LOW, HIGH ;
                            LOW, HIGH, LOW, HIGH ;
                            }
                    else if(line[dIdx].F6)                          // if lower vertical bar
                            {
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            MID, LOW, MID, LOW ;
                            }
                    else if(line[dIdx].F7)                          // if upper vertical bar
                            {
                            MID, HIGH, MID, HIGH ;
                            MID, HIGH, MID, HIGH ;
                            MID, HIGH, MID, HIGH ;
                            MID, HIGH, MID, HIGH ;
                            MID, HIGH, MID, HIGH ;
                            MID, HIGH, MID, HIGH ;
                            MID, HIGH, MID, HIGH ;
                            MID, HIGH, MID, HIGH ;
                            }
    
                    if(dIdx == 7)                                   // hour : minute separator
                            {
                            LOW, Delay10us() ;
                            MID, Delay10us() ;
                            }
                    else if(dIdx == 14)                             // minute : second separator
                            {
                            if(scaler < MAX_SCALER / 2)             // blink 0.5 Hz
                                    {
                                    LOW, Delay10us() ;
                                    MID, Delay10us() ;
                                    }
                            }
                            
                    switch(fIdx)                                    // depending on frame index
                            {
                            case 0:                                 // upper line
                                    if(line[dIdx] & 1)
                                            {
                                            HIGH ;
                                            }
                                    else
                                            {
                                            ZERO ;
                                            }
                                    break ;
                            case 1:                                 // middle line
                                    if(line[dIdx] & 2)
                                            {
                                            MID ;
                                            }
                                    else
                                            {
                                            ZERO ;
                                            }
                                    break ;
                            case 2:                                 // lower line
                                    if(line[dIdx] & 4)
                                            {
                                            LOW ;
                                            }
                                    else
                                            {
                                            ZERO ;
                                            }
                                    break ;
                            }
    
                    dIdx++ ;                                        // next slot
                    if(dIdx == SLOTS)                               // last slot ?
                            {
                            dIdx = 0 ;                              // clear slot
    
                            TRIGGER = 1 ;                           // triggers the scope
                            fIdx++ ;                                // next frame
                            if(fIdx == 3)                           // last frame ?
                                    {
                                    fIdx = 0 ;                      // clear frame
                                    }
                            TRIGGER = 0 ;                           // end trigger
                            }
                    INTCON.T0IF = 0 ;                               // clear timer 0 overflow
                    }
            }
            
    /*
     * main entry
     */
    void    main()
            {
    #ifdef P16F877A
            /*
             * set PORTA as digital I/O
             */
            ADCON1 = 7 ;
            CMCON = 7 ;
    #endif
    
            TRISA = 0b110 ;                                        // PORTA direction register
            PORTA = 0 ;
            
            TRISB = 0 ;                                             // PORTB is output
            PORTB = 0 ;
    
            /*
             * clear buffers
             */
            memset(&line, 0, sizeof(line)) ;
            memset(display, 0, sizeof(display)) ;
    
            OPTION_REG = 0b11011000 ;                               // timer 0 prescaler is 1:1
            INTCON = 0b10100000 ;                                   // start interrupts
    
            for(;;)                                                 // main loop
                    {
                    unsigned char i ;
    
                    if(KEY)                                         // is a button pressed ?
                            {
                            if(KEY_MIN_UP)                          // adjust minutes
                                    {
                                    ss = 0 ;
                                    mn++ ;
                                    }
                            else if(KEY_HH_UP)                      // adjust hours
                                    {
                                    ss = 0 ;
                                    hh++ ;
                                    }
                            mn %= 60 ;                              // prevent minute overflow
                            hh %= 24 ;                              // prevent hours overflow
                            Delay_ms(100) ;                         // debounce
                            }
    
                    /*
                     * prepare display buffer
                     */
                    display[5] = ss % 10 ;                          // seconds
                    display[4] = ss / 10 ;
    
                    display[3] = mn % 10 ;                          // minutes
                    display[2] = mn / 10 ;
    
                    display[1] = hh % 10 ;                          // hours
                    display[0] = (hh > 9) ? hh / 10 : 10 ;          // blank first digit if zero
    
                    /*
                     * prepare time slot flags
                     */
                    for(i = 0 ; i < MAX_DIGIT ; i++)                // for each digit
                            {
                            unsigned char s ;
                            unsigned char *p ;
                            
                            s = septSeg[display[i]] ;               // get 7 segment encoding
    
                            p = &line[sIdx[i]] ;                    // get pointer to time slot, left part of the digit
    
                            (*p).F0 = s.F0 ;                        // a segment
                            (*p).F1 = s.F6 ;                        // g segment
                            (*p).F2 = s.F3 ;                        // d segment
    
                            (*p).F6 = s.F4 ;                        // e segment
                            (*p).F7 = s.F5 ;                        // f segment
    
                            p++ ;                                   // next slot, center part of the digit
    
                            (*p).F0 = s.F0 ;                        // a segment (continuation)
                            (*p).F1 = s.F6 ;                        // g segment (continuation)
                            (*p).F2 = s.F3 ;                        // d segment (continuation)
    
                            p++ ;                                   // next slot, right part of the digit
    
                            (*p).F6 = s.F2 ;                        // b segment
                            (*p).F7 = s.F1 ;                        // c segment
                            }
                    }
            }
    Könnte das in dieser Zeile sein?

    Code:
    const unsigned char     septSeg[11] = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x00 } ;
    ich habe das mal umgewandelt aber ich sehe da noch nichts.


    DEC: 063 |006 |091 |079, |102 |109 |125 |007 |127 |111 |000
    BIN: 111111,0000110,1011011,1001111,1100110,1101101,111 1101,0000111,1111111,1101111,0000000

    die 0x3f könnte ja die '0' sein ...und die 0x06 die '1'

    0111111
    gfedcba = '0'

    0000110 = '1'
    gfedcba

    ...

  9. #9
    Super-Moderator Robotik Visionär Avatar von PicNick
    Registriert seit
    23.11.2004
    Ort
    Wien
    Beiträge
    6.836
    Bingo, das ist sie wohl steht sogar drüber
    3F ist wohl der 0-er , 06 der 1-er, 7F wird der 8-er sein.
    denke, die Tabelle geht von 0-9

    Edit + 1 mal 00 für blank
    mfg robert
    Wer glaubt zu wissen, muß wissen, er glaubt.

  10. #10
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.801
    Wenn das wirklich die Deklaration von line[] ist, dann ist das .F6 kein Standard-C sondern irgend ein Sonderlocken-C.

    Die Uhr ist ja recht simpel, was man so im Video sieht. Das sollte besser dierekt to codieren sein (in welcher Sprache auch immer) anstatt sich durch seltsamen oder undokumentierten Code durchzubeissen.

    Bin momentan auch an ner Scope-Clock für nen AVR ATmega168
    Allerdings muss man do schon recht flott sein und braucht was fixeres als BASCOM:

    http://www.youtube.com/watch?v=MFrI-8tLz-E
    http://gjlay.de/pub/morpheus/index.html
    Disclaimer: none. Sue me.

Seite 1 von 3 123 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •