Embedded system memory mapped I/o

Question

1.00/5 (1 vote)

See more:

Step 1: define a single struct adc_t for all the registers

step 2: assign a pointer to the adc_t struct at the memory-mapped base address

step 3: create a uint16_t pot_read(void), dividing the adc sample by 4 to put 12-bit value into the range from 0 to 1023

step 4: call above function in main

What I have tried:

THIS IS WHAT I HAVE SO FAR.
any help would be appreciated

#include <stdint.h>
#include "led.h"
#include <assert.h>

/*!
* @brief Delay for some number of milliseconds, by wasting CPU cycles.
*
* @param[in] ms  Number of milliseconds to busy-wait.
* @return void
*/


// a single struct for all the registers 
typedef struct {

  uint8_t AD_Control_Register ;
  
  uint8_t unused1[3];
  uint16_t AD_Channel_Select_Register_0;
  
  uint16_t AD_Channel_Select_Register_1;
  
  uint16_t AD_Converted_Value_Addition_Mode_Select_Register_0;

  uint16_t  AD_Converted_Value_Addition_Mode_Select_Register_1;
  
  uint8_t AD_Converted_Value_Addition_Count_Select_Register;
   
  uint16_t AD_Control_Extended_Register ;
  
  uint8_t AD_Start_Trigger_Select_Register;
  
  uint16_t AD_Converted_Extended_Input_Control_Register;
  
  uint16_t AD_Temperature_Sensor_Data_Register;
  
  uint16_t AD_Internal_Reference_Voltage_Data_Register;
  
  uint16_t AD_Data_Register_y;
  
  uint8_t unused2[11];
  uint16_t AD_Sampling_State_Register_01 ;
  
  uint8_t unused3[9];
  uint16_t AD_Sampling_State_Register_23;
  

} adc_t;


// assign a pointer to the memory-mapped base address 
adc_t* adc_regs = (adc_t *)adc_regs_base_address;


/* new function:
   this function will divide the raw ADC sample by 4 to put the 12 bit value into the range 
   0 to 1023 ms
*/
uint16_t pot_read()
{
    // adc_t *adc_regs = get mapped address here;
  
    // create the 12-bit value if necessary (if the registers are 8-bit wide), and divide by four.
    uint16_t adc_value = ((adc_regs -> value_lo) | ((adc_regs -> value_hi & 0x0f) << 8));
    
    // unmap here if necessary
    
    return adc_value / 4;
    
}

Posted 25-Aug-16 7:43am

Member 12674320

Updated 25-Aug-16 12:30pm

v2

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Jochen Arndt · Answer 1 · 2016-08-25T10:35:00

This can't be answered without additional information.

The structure name adc_t indicates that it refers to some kind of ADC (Analogue to Digital Converter) registers. These are usually specified in the datasheet of the embedded system.

Assigning a pointer to this structure requires to know the address. Depending on the system it might be sufficient to just assign the address using casting:

C++

adc_t* adc_regs = (adc_t *)adc_regs_base_address;

where adc_regs_base_address is the hard coded address defined as constant (e.g. by a define statement or as hex address).

If this is not possible there might be a system function to map the address (e.g. mmap(2): map/unmap files/devices into memory - Linux man page[^] with Linux).

The third step requires knowing the ADC registers. With a typical system, use the above mapped memory to read the corresponding register(s), create the 12-bit value if necessary (if the registers are 8-bit wide), and divide by four.
A typical code example might be:

C++

uint16_t pot_read()
{
    //adc_t *adc_regs = get mapped address here;
    uint16_t adc_value = adc_regs->value_lo | 
        ((adc_regs->value_hi & 0x0f) << 8);
    // unmap here if necessary
    return adc_value / 4;
}