Thread: Can I assign address of pointer to array ?

Hi,

I want to assign address of pointer to array.

The reason for this is that the pointer would be a global pointer to have the address of a function pointer argument.

Then at task manager I have a main array buffer which holds transmitting data routine.

This is my example:

Code:

#include <stdio.h>#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>




uint8_t str_counts, i;
const char *str_ptr;
const char *str1 = {"hi how are you ?"};
uint8_t task_buffer[16];


// functions
void data_print(void);
void write_chars(const char *str);




int main(){


    str_counts = strlen(str1);




    str_ptr = str1;
    //task_buffer = str_ptr;




    //printf("%p\n",str1);
    //printf("%p\n",str_ptr);
    //printf("%p\n",task_buffer);


    write_chars(str1);


    return 0;
}


void data_print(void){
    printf("hi");
    task_buffer[0] = str_ptr;
    for(i=0; i<str_counts; i++){
        printf("%c",task_buffer[i]);
        //printf("%c",str_ptr[i]);
    }
}
void write_chars(const char *str){
    str_ptr = str;
    data_print();
}

I commented

Code:

printf("%c",str_ptr[i]);

which is the working line.

Yep, you're right. But I really need a global pointer at least to hold anything that I need to pass to another function. Would agree with me or there's another way of getting the data passed to one function and find it in another one ?

Originally Posted by wolfrose

Yep, you're right. But I really need a global pointer at least to hold anything that I need to pass to another function. Would agree with me or there's another way of getting the data passed to one function and find it in another one ?

Code:

void dosomething( int *p )
{ *p = 1; }

void print( int *p )
{ printf( "%d\n", *p ); }

int main ( void )
{
  int x;

  dosomething( &x );
  print( &x );
}

Originally Posted by Salem

Is data_print really an ISR capable of only printing one character at a time to some external device?

It's a function for transmitting one byte, it's a code for Arduino LCD128x64

This is my complete code, it's working like 90%, I just need to do some improvements.

It's a console simulation for Arduino code. Because I want to design the main FSM code in codeblocks then move the actual implementation to Arduino code.

Code:

/*    Title:    function pointers    Date:    Thu, 30 July 2020
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include <malloc.h>
#include <math.h>


// definitions
#define CURSOR_MOVE         0
#define PIXEL_WRITE         1
#define CHARS_WRITE         2
#define GRAPHICS_SET        3


// enumerations
enum TASK_STATES{CMD, DATA, STRING};
enum TASK_STATES state;


// delay variables
uint32_t dly_st, delay_period;
bool dly_lock, lock;
bool write_lock;
uint16_t i, counter, counts, str_counts, cmd_state;


// command / data variables
char * str_buf;
const char *str_ptr;
const char *str1 = {"hi how are you ?"};
// basic pixel variables
uint8_t y,x, task_buffer[16];
bool row2_4, graphics;


// functions
void task_switcher(void);
void task1(void);
void task2(void);
void write_chars(uint8_t row, uint8_t col, const char *str);
void graphics_set_mode(bool mode);
void transmit(uint8_t cmd);
void delay_routine(void);


// function pointers
void (*fun_ptr)(void);      // main function pointer


int main(){


    //graphics_set_mode(1); // not finished !
     task1();printf("\n\n>>2nd function>>\n\n\n");task2();
    //write_chars(0,0,str1);


    return 0;
}


//////////////////////////////////////////////////////
// lcd transmission commands/data, locks and callback functions
void task_switcher(void){
    if(!dly_lock){
        switch(state){
            case CMD:


                if(counter < counts){
                    transmit(task_buffer[counter]);
                    counter++;
                }
                else{
                    if(cmd_state == PIXEL_WRITE){
                        counts = 4;         // counter = 2 at this point
                        state = DATA;
                    }
                    else if(cmd_state == CURSOR_MOVE || cmd_state == GRAPHICS_SET){
                        write_lock = 0;
                    }
                    else if(cmd_state == CHARS_WRITE){
                        counter = 0;
                        counts = str_counts;
                        state = DATA;
                        strcpy(task_buffer,str_ptr);
                    }
                }


            break;


            case DATA:
                if(counter < counts){
                    transmit(task_buffer[counter]);
                    counter++;
                }
                else{
                    write_lock = 0;
                    counter = 0;            // cleared for multiple pixels writes


                    if(cmd_state == PIXEL_WRITE){
                        counts = 2;
                        state = CMD;        // multiple pixels writes
                        printf("\n");       // for this program data display
                    }


                    if(cmd_state == CHARS_WRITE){




                    }
                }
            break;
        }
    }
    else {delay_routine();}           // first check delay flag
    if(write_lock){task_switcher();}  // still between cmd1-data2
    else if(lock){fun_ptr();}         // method2 function pointer
    //else if(!write_lock){lock = 0;}   // finished writes ? : clear lock
}


void write_chars(uint8_t row, uint8_t col, const char *str){
    if(!lock){
        state = CMD;
        cmd_state = CHARS_WRITE;
        if(graphics){graphics_set_mode(0);}
        counter = 0; counts = 1;
        str_counts = strlen(str);
        str_ptr = str;
        lock = 1;
    }
    // identify row/column location
    else{
        if        (row == 1)task_buffer[0] = (0x80 + (col - 1));
        else if    (row == 2)task_buffer[0] = (0x90 + (col - 1));
        else if    (row == 3)task_buffer[0] = (0x88 + (col - 1));
        else if    (row == 4)task_buffer[0] = (0x98 + (col - 1));
    }


    write_lock = 1;
    task_switcher();
}


// graphics mode
void graphics_set_mode(bool mode){
    if(!lock){
        state = CMD;
        cmd_state = GRAPHICS_SET;
        task_buffer[0] = 1;
        counter = 0; counts = 3;
        write_lock = 0;
        if(mode){
            task_buffer[1] = 11;
            task_buffer[2] = 22;
            graphics = 1;
        }
        else{
            task_buffer[1] = 33;
            task_buffer[2] = 44;
            graphics = 0;
        }
        write_lock = 1;
        lock = 1;
        task_switcher();
    }


}


void task2(void){
    if(!lock){
        fun_ptr = &task2;
        state = CMD;
        cmd_state = PIXEL_WRITE;
        x = 0; y = 0;
        counter = 0; counts = 2;
        lock = 1; row2_4 = 0; write_lock = 0;
    }


    if(y<2 && !row2_4){         // 1st half of lcd
        task_buffer[0] = y;   task_buffer[1] = x;
        task_buffer[2] = 'E';     task_buffer[3] = 'F';
    }




    if(y<4 && row2_4){         // 2nd half of lcd
        task_buffer[0] = y;   task_buffer[1] = x;
        task_buffer[2] = 'G'; task_buffer[3] = 'H';
    }
    x++; if(x>7){y++;x=0;}
    if(y>1){row2_4 = 1;}
    if(y>3){row2_4 = 0;lock = 0;}


    write_lock = 1;
    task_switcher();
}


void task1(void){
    if(!lock){
        fun_ptr = &task1;
        state = CMD;
        cmd_state = PIXEL_WRITE;
        x = 0; y = 0;
        counter = 0; counts = 2;
        lock = 1; row2_4 = 0; write_lock = 0;
    }


    if(y<2 && !row2_4){         // 1st half of lcd
        task_buffer[0] = y;   task_buffer[1] = x;
        task_buffer[2] = 'A'; task_buffer[3] = 'B';
    }




    if(y<4 && row2_4){         // 2nd half of lcd
        task_buffer[0] = y;   task_buffer[1] = x;
        task_buffer[2] = 'C'; task_buffer[3] = 'D';
    }
    x++; if(x>7){y++;x=0;}
    if(y>1){row2_4 = 1;}
    if(y>3){row2_4 = 0;lock = 0;}


    write_lock = 1;
    task_switcher();
}


// command tx
void transmit(uint8_t cmd){
    if(state == CMD)      {printf("%d ",cmd);}
    else                   {printf("%c  ",cmd);}
}


// delay routine
void delay_routine(void){if(dly_lock){dly_lock = 0;}}

Originally Posted by flp1969

Code:

void dosomething( int *p )
{ *p = 1; }

void print( int *p )
{ printf( "%d\n", *p ); }

int main ( void )
{
  int x;

  dosomething( &x );
  print( &x );
}

OK, got the idea.

So I can change the whole behavior of functions by changing the type of argument pass by address and not by a copy of that variable.

But anyway, I need a buffer in my code and most of embedded system codes, they use a lot of global variables.

Thank you so much for writing a code for me. It would take me a serious time studying this code.

I know that structs are useful but I'm moving step by step in using more advanced programming skills.
I used to program in a very basic programming styles, starting with normal global variables, then the next step was the arrays.

Then I moved to basic pointers, and now I'm working with enums.

Now working with enums, they are basically a defined names with values and the object of the enum would be the variable that would work like the register to hold a value each time.

I did the same method using definitions and a normal static global variable, so it's basically the same.


------------------------------------------------------------------------------------------------------------------

Just did a 2nd quick check for the code, it seem a bit complicated to me as I have been doing basic C programming with Arduino for like 4 years but this code still more than my level.

Just a quick question, why you use typedefs for the structs and enums ?