AVR Freaks

I was bored.    So I downloaded the ZIP file pointed from clawson.    And compiled with CV.

// rf pad by Alberto Ricci Bitti - a.riccibitti@iname.com
// version 2 - 1 may 2000
// designed for AT90S2313 and GNU C compiler (-Os option used)
// this sofwtware is distributed under the GNU public license (www.gnu.org) 

 
#include <io.h>
//#include <inttypes.h>
//#include <interrupt.h>
//#include <signal.h>
//.kbv several macros for CV. 
//.kbv Actual Code edits are marked with .kbv
//.kbv note that there is a #warning about codes[3] out of range
#include <string.h>
#define inp(p)    p
#define outp(val, p) p = val
#define sbi(p, b) p |= (1<<(b))
#define cbi(p, b) p &= ~(1<<(b))
#define cli()     #asm("cli")
#define sei()     #asm("sei")
#define SIGNAL(x) interrupt [x] void isr##x(void)
#define SIG_INT0  EXT_INT0
#define SIG_INT1  EXT_INT1

//replace here your own ASCII key combination / 12 bit rf codes pairs
//very important: the combination must be the same length as the key_combination[] (see below)
#define COMBINATION_1     "111111"
#define RF_CODE_1        0xAAA        //will be AA 0A in code dump

#define COMBINATION_2    "222222"
#define RF_CODE_2        0xBBB        //will be BB 0B in code dump

#define COMBINATION_3    "333333"
#define RF_CODE_3        0xCCC        //will be CC 0C in code dump

//dirty trick: making it a volatile array, we force compiler to take codes from RAM
//instead of using optimized direct instructions as ldi.
//this allows modifying the codes directly on the hex code for those without a compiler
volatile unsigned int codes[3] = { RF_CODE_1, RF_CODE_2, RF_CODE_3 };

//handy bit masking macro
#define byte( b7,b6,b5,b4,b3,b2,b1,b0) (b7*128+b6*64+b5*32+b4*16+b3*8+b2*4+b1*2+b0)

#define F_CPU            4000000      /* 4Mhz */
#define UART_BAUD_RATE      9600      /* 9600 baud */
#define UART_BAUD_SELECT (F_CPU/(UART_BAUD_RATE*16l)-1)

// lo level hardware drive macros
#define BEEPER_ON    sbi(PORTB, 1)
#define BEEPER_OFF  cbi(PORTB, 1)
#define RF_ON       sbi(PORTB, 0)
#define RF_OFF      cbi(PORTB, 0)
#define SEL_COL_0   { sbi(PORTB, 4); sbi(PORTB, 5); sbi(PORTB, 6); cbi(PORTB, 7); }
#define SEL_COL_1   { sbi(PORTB, 4); cbi(PORTB, 5); sbi(PORTB, 6); sbi(PORTB, 7); }
#define SEL_COL_2   { sbi(PORTB, 4); sbi(PORTB, 5); cbi(PORTB, 6); sbi(PORTB, 7); }
#define SEL_COL_3   { cbi(PORTB, 4); sbi(PORTB, 5); sbi(PORTB, 6); sbi(PORTB, 7); }

#define SEL_COL_ALL { cbi(PORTB, 4); cbi(PORTB, 5); cbi(PORTB, 6); cbi(PORTB, 7); }

// important constants 
#define MAX_ROWS 4
#define MAX_COLUMNS 4
#define MAX_KEYS (MAX_ROWS * MAX_COLUMNS)

#define NO_COLUMN MAX_COLUMNS
#define NO_ROW MAX_ROWS
#define NO_KEY '?'

//keyboard ASCII matrix, replace your own characters here
//DON'T USE 0x00 as it breaks string compare
const unsigned char keys[MAX_ROWS][MAX_COLUMNS] = {
    {'1', '2', '3', 'A' },    
    {'4', '5', '6', 'B' },    
    {'7', '8', '9', 'C' },    
    {'*', '0', '#', 'D' }
};

//function prototypes
void wait(unsigned long delay);
unsigned char find_column(void);
unsigned char decode_row( unsigned char col);
unsigned char key_detected(void);



//returns 1 if key pressed, 0 otherwise
unsigned char key_detected(void)
{    register unsigned char tmp;
    tmp = inp(PIND);
    tmp &= byte(0,0,1,1, 1,1,0,0);
    if ( tmp == byte(0,0,1,1, 1,1,0,0) )
        return 0;
    return 1;
}

// returns the column of the key being pressed
// NO_COLUMN if no keys pressed
unsigned char find_column(void)
{
    unsigned char c;
    
    for (c=0; c<MAX_COLUMNS; c++)
    {    switch(c)
        {
        case 0: SEL_COL_0; break;
        case 1: SEL_COL_1; break;
        case 2: SEL_COL_2; break;
        case 3: SEL_COL_3; break;
        };
        wait(100);
        if ( key_detected() )
            break;
    }
    return c;
};

// returns the ASCII code of key being pressed, NO_KEY if no keys pressed
// requires key's column 
unsigned char decode_row( unsigned char col)
{
    unsigned char mask, row;

    if (col == NO_COLUMN)
        return NO_KEY;  
            
    mask = inp(PIND) & byte(0,0,1,1, 1,1,0,0);
    switch(mask)
    {
    case byte(0,0,1,1, 1,0,0,0):
        row = 2;
        break;
    case byte(0,0,1,1, 0,1,0,0):
        row = 1;
        break;
    case byte(0,0,1,0, 1,0,0,0): //diode effect: two bits low at once
        row = 0;
        break;
    case byte(0,0,0,1, 0,1,0,0): //diode effect: two bits low at once
        row = 3;
        break;
    default: 
        return NO_KEY;
    };
    return keys[row][col];
};

// simple wait loop, compiler and optimization dependant (-Os option used)
void wait(unsigned long delay)
{
    while (delay--)
    {
        #asm("nop");                       //.kbv
    };
};
    
// calibration macro for the above wait loop
#define uS(x)  ( ( (x) * 550L)/1000)

// define sleep macro
//#define sleep()  asm volatile ("sleep" ::)
#define sleep()  #asm("sleep")              //.kbv

// define handlers, just to be safe
SIGNAL(SIG_INT0)
{
};

SIGNAL(SIG_INT1)
{
};


// generate the RF code in the 11 LSB of the parameter
// the code is repeated 15 times
// 270 uS and 550 uS are the times measured on my commercial remote
// control with a fresh battery
void rf_code(unsigned int code)
{
    unsigned int mask;
    unsigned char times;
    
    for (times=0; times < 15; times++)
    {    
        
        // start bit
        RF_ON;
        wait(uS( 270 ));
        
        for (mask = 1 << 11; mask != 0; mask >>= 1)
        {
            RF_OFF;
            if (code & mask)
            {
                //tx 0
                wait( uS(550) );
                RF_ON;
                wait (uS(270) );
            }
            else            
            {    //tx 1
                wait( uS(270) );
                RF_ON;
                wait( uS(550) );
            };
        };
        RF_OFF;    
        wait( uS( 10000));
    };
}
        

void main( void )                 //.kbv
{
       unsigned char key_sequence[ sizeof(COMBINATION_1) ] = "??????";  //be sure this is as long as your combination!
       unsigned char i;                    //used to shift incoming combination string
       
    outp(0xff,PORTB);                       // all pins pulled up on inputs 
    outp(0xff,DDRB);                           // use all pins on PortB for output 

    outp(0xff,PORTD);                       // all pins pulled up on inputs 
    outp(0x00,DDRD);                           // use all pins on PortD for input 
    
    //uart init: enable RxD/TxD and ints, then set baud rate
    outp(( 1<<RXEN)|(1<<TXEN), UCR );       
    outp( (unsigned char) UART_BAUD_SELECT, UBRR );          
    
    //enable sleep, power-down mode, interrupt on low level of either INT0 or INT1
    outp( (1<<SE)|(1<<SM), MCUCR);

    //enable external interrupts
    outp( (1<<INT1)|(1<<INT0), GIMSK);
    
    // tell the world we're alive with a long beep
       wait(400000);
       BEEPER_OFF;
       RF_OFF;
       
       for ( ; ; )
       {    
           
           
        // all keys active
        SEL_COL_ALL;
        wait(10000);

           //wait for the key being released
        while ( key_detected() )
        {
            wait(50000);
        };
        
        //time to go bed! re-enable interrupts and shut off
        sei();
        sleep();
            
           // ...ZZZ...  ...the AVR stays asleep until next keypress...
           
           //key pressed: dummy instruction just to be safe 
           //(some micros skip the instruction next to sleep)
           #asm("nop");                //.kbv
           
           // avoid annoying interrupts until key released
        cli(); 

        //shift combination left, decode key and add it to current combination
        i = 0;
        while( ( key_sequence[i] = key_sequence[i+1]) != 0)
            i++;
        // i points to last character in string
        key_sequence[ i ] = decode_row( find_column() );

        // send key ASCII code to serial port
        outp(key_sequence[ i ], UDR);
    
        // compare combination to valid codes
        // (add here other combinations if needed)
        if ( ! strcmp(key_sequence, COMBINATION_1)    )    
        {
                BEEPER_ON;
                rf_code( codes[1] );    //indirect addressing: see codes[] declaration
                BEEPER_OFF;
           }
           else if ( ! strcmp(key_sequence, COMBINATION_2)    )    
        {
                BEEPER_ON;
                rf_code( codes[2] );
                BEEPER_OFF;
           } 
           else if ( ! strcmp(key_sequence, COMBINATION_3)    )    
        {
                BEEPER_ON;
                rf_code( codes[3] );
                BEEPER_OFF;
           };
           // key beep
           BEEPER_ON;
           wait(15000);
           BEEPER_OFF;
    };
};

Untested.   I have no idea what it is supposed to do.

David.

When avr-gcc was first invented,   it was not very good with handling ports etc.

So it came with functions or macros like inp(), outp(), sbi() etc

They don't really do anything special.   Modern compilers handle PORTx, PINx etc seamlessly.

I notice that you posted exactly the same subject in Jan/Feb 2013.

It looks as if you got exactly the same replies.    e.g. Cliff built it for you.   And pointed out the array bound problem.

i.e. he spent 10-15 minutes of his life in 2013.   I did likewise in 2014.

If something does not work properly,   you need to explain it in English.   i.e. what you expected.   what you actually got.

It would take a LOT of time for Cliff or I to study the program.

David.

Exactly the same reason in 2014 as the reason in 2013 when Cliff explained it to you!

i.e.  an int array[3] has 3 members: array[0], array[1] and array[2]

array[3] would be the 4th member (which has not been allocated)

David.

Timing will depend on you actually having a 4MHz crystal.    Which is an unusual value.

Or perhaps you are using the 8MHz RC.   In which case you need to divide by 2 to get 4MHz.    (with CLKPR)

And obviously your CV project Configuration needs to be told 4MHz.

But the real problem is the Wait() function.

Both CV and GCC would give you 100% precision with delay_us() or delay_ms()

Please describe exactly where your problems lie.   e.g. baud rate or the infra-red pulses.

David.