ADC Measurements and Servo Motion Tracking.

[german_wings]

Hello,

I am struggling to solve 2 problems , 

1st : 

I have 4  AAA cells (2 in series each ) to make a good power source !

The Problem :

I have to measure the battery voltage(Input Line) to blink a LED when it falls below 2.0V , The Experiment setup I am using contains a POT (10K) which acts as a draining battery(voltage drops) , but the value I get from the wiper into my analog pin of NRF is between 53 to 450 occasionally going to 800 , however on arduino its spot on between 0 to 1024 , can I get the same here , the 10 bit SAADC res is defined in SDK Config I didn't touch that. Is the value 53 to 450 correct ??

2nd :

I have a servo ! connected to the same power source , I have a 4th wire on the servo that gives me the position of the servo !

The plan

I am going to write a function that increments the servo position a little and then monitor the analog signal on the 4th wire if it changes the shaft moved , if it didn't I will assume that something is blocking the shaft , so I will reverse the servo , and stop it from damaging something.

The problem :

I do not know how to convert the value that i receive from the SAADC example (I connected a 10K POT on A0 pin ) , The Infocenter says NRF52 is capable of 8Bit / 10 bit resolution , Where to select the resolution , Coming from Arduino analogRead is the goto function to do such calculations , my 10K POT shows 53 to 450 integer values(is that right ??) how do I map these values to voltage  , and what resolution is those values ?

On the servo problem , I am using a PWM Library , for some odd reasons my Servo uses '2' as 0 position and '15' as 180Deg position(again is that right ??) , on the arduino side 0 ~ 255  and I have 255 Positions to put my servo in , here NRF52 However its 2~15 only. , However I am fine with 2~15 as long as Servo Moves 90 Deg , now I have that 4th wire to track the position again , how do I read it , compare it to previous position , then move again.

How do I get it to work the arduino way , that is 0 is servo 0 and 255 is servo 180 ??

I understand that the Nordic Product is very powerful and could get these things done easily if used the right way. However I am no expert in electronics nor an expert in C Programming , I mostly do python (good language at Application Level) , so In case if someone answers to my question please be brief and simplify with example and comments (I understand its more work to answer to noob).

Also if I am thinking if I fail to solve the problem with reasonable solution , I would put on an arduino that communicates with an NRF Chip via GPIO Signals (Poor Mans I2C Hahaha (Coz I have not dared to look at the I2C Example)) , The arduino would be my primary chip, that only toggles NRF When in need of BLE , which I do not want to do , since I know the chip is capable of doing what I want.

My Hardware and Setup

SDK 150

BLE Example is being used

NRF52 DK

Servo Code 

#include <stdbool.h>
#include <stdint.h>
#include "nrf.h"
#include "app_error.h"
#include "bsp.h"
#include "nrf_delay.h"
#include "app_pwm.h"

APP_PWM_INSTANCE(PWM1,1);                   // Create the instance "PWM1" using TIMER1.

int main(void)
{
    ret_code_t err_code;
    uint8_t SERVO_PIN = 4;

    /* 1-channel PWM, 50Hz, output on DK LED pins, 20ms period */
    app_pwm_config_t pwm1_cfg = APP_PWM_DEFAULT_CONFIG_1CH(20000L, SERVO_PIN);

    /* Switch the polarity of the first channel. */
    pwm1_cfg.pin_polarity[0] = APP_PWM_POLARITY_ACTIVE_HIGH;

    /* Initialize and enable PWM. */
    err_code = app_pwm_init(&PWM1,&pwm1_cfg,NULL);
    APP_ERROR_CHECK(err_code);
    app_pwm_enable(&PWM1);

    uint8_t servo_pos_max = 10;
    uint8_t servo_pos_min = 5;
    while (true)
    {
        /* Set the duty cycle - keep trying until PWM is ready... */
        while (app_pwm_channel_duty_set(&PWM1, 0, servo_pos_max) == NRF_ERROR_BUSY);
        nrf_delay_ms(5000);
        while (app_pwm_channel_duty_set(&PWM1, 0, servo_pos_min) == NRF_ERROR_BUSY);
        nrf_delay_ms(5000);
     }

}

The Servo Code , Jitters the servo back and forth briskly sometimes and sometimes it works properly ! I have attached a video of this code working below please have a look , The servo ain't busted , it works very well on Arduino , also I dont know where did Sigurd got 5 and 10 value from why not 0 and 255 ???

SAADC Example Code for analog measurements (Would not it be nice if it could have been as simple as just one function as in Arduino ! (Sure this one gives more flexibilty)) or the maximum is only 3V ? measurement on Analog Pin..

void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{
    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {
        ret_code_t err_code;

        err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAMPLES_IN_BUFFER);
        APP_ERROR_CHECK(err_code);

        int i;
        printf("ADC event number: %d \n", (int)m_adc_evt_counter);
        int average = 0;

        for (i = 0; i < SAMPLES_IN_BUFFER; i++)
        {
            //printf("%d \n", p_event->data.done.p_buffer[i]);
            average = average + p_event->data.done.p_buffer[i];
        }
        printf("Average %d \n",(average / SAMPLES_IN_BUFFER));
        average = average / SAMPLES_IN_BUFFER;

        double voltage = (((average-50.0f) / (500.0f-50.0f)) * (5.0f-1.0f)) + 1.0f;
        printf("Voltage %ld \n",voltage);

        m_adc_evt_counter++;
    }
}

Here is the Arduino Code for Simple Voltage Measurement ! , I was kind of looking something along these lines...

float floatMap(float x, float in_min, float in_max, float out_min, float out_max) {
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

// the setup routine runs once when you press reset:
void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
}

// the loop routine runs over and over again forever:
void loop() {
  // read the input on analog pin A0:
  int analogValue = analogRead(A0);
  // Rescale to potentiometer's voltage (from 0V to 5V):
  float voltage = floatMap(analogValue, 0, 1023, 0, 5);

  // print out the value you read:
  Serial.print("Analog: ");
  Serial.print(analogValue);
  Serial.print(", Voltage: ");
  Serial.println(voltage);
  delay(10);
}

[haakonsh]

1. SAADC
   
   Any ADC will output some amount of noise. With our SAADC you should expect +/- 4lsb10 on an average set-up, that's +/- 4 codes at 10 bit resolution, or +/- 2 on 8-bit resolution. If you see anything more than that you have a noisy input.
   You can verify this by powering using the DK and configuring the SAADC in single-ended mode, with the positive input(CH[0].PSELP) connected to VDD. The output will always vary somewhat.
   
   A potmeter's wiper blades are inherently noisy when they are operated, because of poor electromechanical connection between the wiper blade and the wiper track. You can easily see large jumps in analog voltages in cheap potmeters. You can verify this with an oscilloscope. 
   un-soldered board-to-board cables have terrible electromechanical contacts that will introduce large amount of noise if they are fiddled with. They are also unshielded which makes them susceptible to Electro-Magnetic Interference. 
   
   The output of the SAADC with respect to the input in single-ended mode is:
   
   Result = (Vin * Gain/ Reference) * (2^(resolution) - 1) , where resolution is in number of bits.
   
   f.ex Vin = 2.2V , reference = 0.6V, Gain = (1/6), resolution = 10 bits:
   Result = (2.2V * 1/6)/0.6V * (2^(10) -1) = (0.367/0.6)V * 1023 = 625. 
   
   I see that you're doing a lot of averaging in your application code. The SAADC has an oversampling feature that can sample up to 256 samples and average them automatically. The output buffer will then only contain averages of up to 256 samples. See Oversampling and SAADC driver API docs. 
   
   
   
2. PWM
   A typical servo requires a PWM signal with a specific frequency and duty-cycle to operate, where the frequency is fixed and the duty-cycle determines the angle/rotational speed of the servo. Your servo should have a data sheet that specifies what frequency and duty-cycles are valid, and you need to control the PWM signal accordingly. Most servos operate with a frequency of 50Hz and a duty cycle between 5-20%.
   
   From the Pulse-width modulation (PWM) library's API docs I can see that the function app_pwm_channel_duty_set takes a parameter called 'duty' that is the duty-cycle in %(0-100). This will give you a very low-resolution PWM that might not be suitable for use with a servo. If you need a higher resolution you will need to use the PWM — Pulse width modulation or create one with a TIMER — Timer/counter and a GPIOTE — GPIO tasks and events. 
   
   
3. Servo jitter.
   This is most likely caused by your application reacting to noise in the servos analog signal and reversing the direction of rotation.
   Note that most servos have some jitter inherent in its control circuitry. 

[german_wings]

Hello,

Thank You for your response (I was eagerly waiting for someone from Nordic to respond ! )

I tried to understand your reply , but could not understand and apply it to my situation, Here is what I am thinking please validate it.

Is the Analog Pin Capable of taking 5V inside it and then give me a 10Bit Resolution value i.e between 0 and 1024 ??? Can you give me a very simple example to read the analog values (as in the Arduino Snippet code). I checked the POT Reading when connected to Arduino. The Analog value the Arduino shows when converted to Voltage matches with the voltage shown on my Multimeter(I dont have an Oscilloscope)

On the PWM Issue I am facing

I followed Sigurds (Search : Example code for talking to the Servo) Response to another question. And used the same code to talk to I checked the Servo(SG90 Servo) Doc (I am attaching a image of the datasheet Please refer to it)

Heres what I deduced

1.5ms pulse (Total 20ms) will put the servo to 0 Deg (So Duty Cycle is 7.5 ~ 8)

2ms pulse (Total 20ms) will put the servo to +90 Deg (So Duty Cycle is 10)

1.0ms pulse (Total 20ms) will put the servo to -90 Deg (So Duty Cycle is 5)

If I put these values (8/10/5) the servo does moves but jitters as in Arduino (This Problem is not visible on the Arduino Board though)

If Sigurds Response was not correct or not the right way. Please give me an example to do a sweep in a incremental way like it does in Arduino Snippet with PWM You directed me too (I tried to fiddle with the PWM Driver example but did not understand the nrf_simple_playback function)

Had the servo had some problem inside its circuitry it would have been apparent with arduino as well , but that is not the case. Is there something that can be done on the software side to fix this kind of issue , also what do you mean by resolution ?? if PWM Library is not the right way to control the servo then what is ??

Thank You,

[haakonsh]

german_wings said:

Is the Analog Pin Capable of taking 5V inside it and then give me a 10Bit Resolution value i.e between 0 and 1024 ??? Can you give me a very simple example to read the analog values (as in the Arduino Snippet code). I checked the POT Reading when connected to Arduino. The Analog value the Arduino shows when converted to Voltage matches with the voltage shown on my Multimeter(I dont have an Oscilloscope)

You cannot measure 5V with our device, the maximum allowed voltage on any GPIO is VDD+0.3V, see Absolute maximum ratings. 

You likely won't catch transients like that on a multimeter.

 

The Timer Example shows you how to use the TIMER and toggle an LED, that's a basic PWM. You just need to modify the frequency and duty cycle.

german_wings said:

If I put these values (8/10/5) the servo does moves but jitters as in Arduino (This Problem is not visible on the Arduino Board though)

If you remove the ADC feedback loop from the servo control, does it still behave erratically?
 

german_wings said:

Had the servo had some problem inside its circuitry it would have been apparent with arduino as well , but that is not the case. Is there something that can be done on the software side to fix this kind of issue

I'm telling you there is a certain amount of jitter in any servo, especially in cheap ones, and it stems from its control loop. 
 

german_wings said:

also what do you mean by resolution ??

The resolution of your duty-cycle. If you have 5 decimal values between your lowest and highest value then you have less than 3bit resolution.
 

german_wings said:

if PWM Library is not the right way to control the servo then what is ??

 Anything that will give you higher than 3bit resolution. A TIMER based one should give you more than 8bits. 

[german_wings]

Thank You ,

Here's a few question I have.

After going through the Documentation of PWM Driver

How is Base Clock Frequency and Top Value related to PWM Period (Is there a formula)

To Create a poor mans pwm I wrote a function :

static void poor_mans_pwm() // does a 10% Duty Cycle and 5%duty Cycle but cant do much except a 90Deg sweep
{
  nrf_gpio_cfg_output(4);
  while(true)
  {
    nrf_delay_ms(500);
    nrf_gpio_pin_write(4,1);
    nrf_delay_ms(1);
    nrf_gpio_pin_write(4,0);
    nrf_delay_ms(19);

    nrf_delay_ms(500);

    nrf_gpio_pin_write(4,1);
    nrf_delay_ms(2);
    nrf_gpio_pin_write(4,0);
    nrf_delay_ms(18);
  }
}

I really want to control my motor as simply as Arduino Can Do ! , Can You write me an example with TIMER or PWM Driver or GPIOTE whatever you find easy and at your ease to control my servo from 0 to 180Deg (I understand it might be quite a work but the Docs are really difficult for me to understand)

haakonsh said:

The Timer Example shows you how to use the TIMER and toggle an LED, that's a basic PWM. You just need to modify the frequency and duty cycle.

How do I modify Duty Cycle ?? Frequency was spot on ! changed

from here

//Timer Example

uint32_t time_ms = 20; //Time(in miliseconds) between consecutive compare events.

I am trying to understand , I hope the Nordic Team will help me.

Thank You,

[german_wings]

?? Any updates on this one ? That might be helpful ??

[german_wings]

Hello Devzone ,

Let me know if there's any updates or any information to help me ...

Thank You,

[haakonsh]

A TIMER runs on the 16MHz peripheral clock, but you can lower the frequency by using the PRESCALER register. A prescaler divides the 16MHz clock by an integer number between 0 and 9, as set in the PRESCALER register. A prescaler of 0 yields 16MHz and a prescaler of 8 yields 16/8 = 2MHz.

You need to use two compare values, one to set the PWM frequency(top value) and one to set the duty cycle. 

First, you need to set the PWM frequency of 50Hz (20ms period). With a 16MHz clock you need to count for 16MHz/50hz = 320000 ticks. If you use CC[0] as the TOP value, you need to set it to 320000. This will generate an event after the TIMER has counted for 320000 ticks of the 16MHz clock. 
At this point, we need to do two things, (1) clear the TIMER value to 0, and (2) set the output pin high. You can automatically clear the TIMER by setting the COMPARE0_CLEAR bit in the SHORTS register. 

Second, you need to set the duty cycle. You can use CC[1] to control the duty cycle by setting it to a value from 1 to 320000, where 160000 will yield a duty-cycle of 50%. You must use this event to set the output pin low. 

By changing the value of CC[1] you change the duty cycle, and you have a resolution of ~18-19 bits. 

The gpiote example in the SDK explains how you can use any peripheral event to control the output of a GPIO. 
The timer example explains how to use the timer.