Probleme bei C->Basic Frequenzmesser

Ich habe folgenden C Code:

Code:

---

/*
  Jesper Hansen <jesperh@telia.com>
 
  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License
  as published by the Free Software Foundation; either version 2
  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software Foundation,
  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/



/*

        Simple Digital Guitar Tuner
        ---------------------------
        version 1.0                2001-02-12        jesper
       


        PIN assignements on the 2323
       
        PB0                High LED
       
        PB1                Input pin
       
        PB2                Low Led

*/


#include <io.h>
#include <signal.h>




#define F_CPU                                11059200                        // CPU clock frequency
#define PRESCALER                        64                                        // CPU prescaler value



#define BASE_FREQUENCY                (F_CPU/PRESCALER)        // counter frequency       

#define TUNING_FORK_A                440.0                                // "base" A
#define NOTE_DIFF                        1.05946309436                // the 12'th root of 2


#define E_STRING        164.81                                                // top string (1)
#define A_STRING        220.00
#define D_STRING        293.66
#define G_STRING        391.99
#define B_STRING        493.88                               
#define EH_STRING        659.26                                                // bottom string (6)


// The guitar note span
//  # # #  # #  # # #  # #
//EF G A BC D EF G A BC D E
//1    2    3    4 * 5    6
//

unsigned int Center_Count[] =
{
        BASE_FREQUENCY/EH_STRING,                        // High E
        BASE_FREQUENCY/B_STRING,                        // B
        BASE_FREQUENCY/G_STRING,                        // G
        BASE_FREQUENCY/D_STRING,                        // D
        BASE_FREQUENCY/A_STRING,                        // A
        BASE_FREQUENCY/E_STRING,                        // Low E
};

unsigned int Transition_Count[] =
{
        BASE_FREQUENCY/(B_STRING+(EH_STRING-B_STRING)/2),        // E to B
        BASE_FREQUENCY/(G_STRING+(B_STRING-G_STRING)/2),                // B to G
        BASE_FREQUENCY/(D_STRING+(G_STRING-D_STRING)/2),                // G to D
        BASE_FREQUENCY/(A_STRING+(D_STRING-A_STRING)/2),                // D to A
        BASE_FREQUENCY/(E_STRING+(A_STRING-E_STRING)/2),                // A to E
};




volatile unsigned char count_hi;        // overflow accumulator

//
//timer 0 overflow interrupt
//
SIGNAL(SIG_OVERFLOW0)       
{
        count_hi++;                                                // increment overflow count
}


//----------------------------------------------------------------------------
// Main Lupe
//----------------------------------------------------------------------------


int main(void)
{
        unsigned int i;
        unsigned int count;
       

 //------------------------------
 // Initialize
 //------------------------------

        cbi(DDRB, 1);                        // PB1 is input
        cbi(PORTB, 1);                        // no pullups active

       
        sbi(DDRB, 0);                        // PB0 is ouput, High LED
        sbi(DDRB, 2);                        // PB2 is ouput, Low LED


        outp(0x03,TCCR0);                // set prescaler to f/64 (172.8 kHz @ 11.0592 MHz)

        sbi(TIMSK,TOIE0);                // enable interrupt on timer overflow
        asm volatile ("sei");        // global interrupt enable

 

 //----------------------------------------------------------------------------
 // Let things loose
 //----------------------------------------------------------------------------                       


        while (1)                                                                // loop forever
        {
                count = 0;                                                        // clear sample count
                loop_until_bit_is_set(PINB,1);                // wait for something to happen

                // got a high edge
                // start sampling
               
                outp(0,TCNT0);                                                // clear counter               
                count_hi = 0;                                                // clear hi count

               
                // sample loop
               
                for (i=0;i<32;i++)
                {
                        while (bit_is_set(PINB,1))                // ignore hi->lo edge transitions
                                if (count_hi > 80)                        // skip if no edge is seen within
                                        break;                                        // a reasonable time

                        while (bit_is_clear(PINB,1))        // wait for lo->hi edge
                                if (count_hi > 80)                        // skip if no edge is seen within
                                        break;                                        // a reasonable time

                        count += (count_hi << 8) + inp(TCNT0); // get counter value
                        outp(0,TCNT0);                                        // clear counter               

                        if (count_hi > 80)                                // skip if counter has accumulated a
                                break;                                                // too high value

                        count_hi = 0;                                        // clear hi count
                }




                // initially turn off both leds
                sbi(PORTB,0);
                sbi(PORTB,2);

                if (count_hi <= 80)                                        // if count is reasonable
                {

                        count = count >> 5;                                // average accumulated count by dividing with 32
       
                        // now we have to find the correct string
                                               
                        // go through transition frequencies
                       
                        for (i=0;i<sizeof(Transition_Count)/sizeof(Transition_Count[0]);i++)
                        {
                                if (count < Transition_Count[i])        // stop if lower than this transition count
                                        break;
                        }                               
                       
                        // i now holds the string index
                       
                        // check the count for a match, allowing
                        // 1 extra count "hysteresis" to avoid too
                        // much LED flickering
                       
                        if (count-1 <= Center_Count[i])                        // if count <= this string count
                                cbi(PORTB,0);                                                // light "Too High" LED
       
                        if (count+1 >= Center_Count[i])                        // if count >= this string count
                                cbi(PORTB,2);                                                // light "Too Low" LED
                }
        }


}

---

Er ist für ein Gitarrenstimmgerät.

Ich benötigen das gleiche Prinzip für einen einfachen Frequenzmesser, der mir die Frequenz per RS232 sendet.

Code:

---

$regfile = "m32def.dat"
$crystal = 11059200

Dim I As Integer
Dim Count As Integer
Dim Count_hi As Byte

Config Pinb.1 = Input
Portb = &B00000000

Config Timer0 = Timer , Prescale = 64
On Timer0 Ttimer0isr
Enable Timer0

Enable Interrupts

Do
 Count = 0
 Do
  If Pinb.1 = 1 Then Exit Do
 Loop
 Count_hi = 0

 For I = 0 To 31

  While Pinb.1 = 1
  If Count_hi > 80 Then Exit While
  Wend

  While Pinb.1 = 0
  If Count_hi > 80 Then Exit While
  Wend

  Count = Count_hi + Timer0
  Timer0 = 0

 Next I
Loop

Ttimer0isr:
 Timer0 = 172800
 Incr Count_hi
Return

---

Leider haben mir meine MicrocontrollerC kentnisse um den rest rauszufriemeln.

Da dies ein (IMHO) sehr interessantes projekt ist wäre es sehr hilfreich wenn ihr mir helfen könntet.

Der dazugehörige schaltplan: http://www.myplace.nu/avr/gtuner/index.htm

Mfg
Tobi