Reading 1023 value to 255

I don't want to hijack this thread but am interested to know what test using values from analogRead would produce non uniform results with map?

You might want to perform some testing before declaring that I’ve made a mistake.

You are correct! My mistake! I really thought you meant something else, but I just interpreted you wrong.

Here’s some test code… see the sample output below the code.

0, 85, 170 are output five times instead of 4 for MAP… but DIV by 4 yields 4 results for each and every number from 0 to 255.

Not cool that Map feature… but ya know it does have a special place in my heart for funky scaling…

When I need to scale A/D to PWM or 0-255… I will use divide by 4 :wink:

Thanks CB! A thousand apologies.

/* Map Vs. DIV by 4 */
#include <SoftwareSerial.h>
int val;

void setup() {
  Serial.begin(9600);
  Serial.println("MAP --- DIV4");
}

void loop()
{
  for(int x=0;x<=1023;x++)
  {
    val = map(x, 0, 1023, 0, 255);  //Scales x = 0-1023 to val = 0-255
    Serial.print(val); //Prints mapped value
    Serial.print("     ");
    Serial.println(x/4); //Prints x/4
  }
}

/*
MAP --- DIV4
0     0
0     0
0     0
0     0
0     1
1     1
1     1
1     1
1     2
2     2
2     2
2     2
2     3
3     3
3     3
3     3
3     4
4     4
4     4
4     4
4     5
5     5
5     5
5     5
5     6
6     6
6     6
6     6
6     7
7     7
7     7
7     7
7     8
8     8
8     8
8     8
8     9
9     9
9     9
9     9
9     10
10     10
10     10
10     10
10     11
11     11
11     11
11     11
11     12
12     12
12     12
12     12
12     13
13     13
13     13
13     13
13     14
14     14
14     14
14     14
14     15
15     15
15     15
15     15
15     16
16     16
16     16
16     16
16     17
17     17
17     17
17     17
17     18
18     18
18     18
18     18
18     19
19     19
19     19
19     19
19     20
20     20
20     20
20     20
20     21
21     21
21     21
21     21
21     22
22     22
22     22
22     22
22     23
23     23
23     23
23     23
23     24
24     24
24     24
24     24
24     25
25     25
25     25
25     25
25     26
26     26
26     26
26     26
26     27
27     27
27     27
27     27
27     28
28     28
28     28
28     28
28     29
29     29
29     29
29     29
29     30
30     30
30     30
30     30
30     31
31     31
31     31
31     31
31     32
32     32
32     32
32     32
32     33
33     33
33     33
33     33
33     34
34     34
34     34
34     34
34     35
35     35
35     35
35     35
35     36
36     36
36     36
36     36
36     37
37     37
37     37
37     37
37     38
38     38
38     38
38     38
38     39
39     39
39     39
39     39
39     40
40     40
40     40
40     40
40     41
41     41
41     41
41     41
41     42
42     42
42     42
42     42
42     43
43     43
43     43
43     43
43     44
44     44
44     44
44     44
44     45
45     45
45     45
45     45
45     46
46     46
46     46
46     46
46     47
47     47
47     47
47     47
47     48
48     48
48     48
48     48
48     49
49     49
49     49
49     49
49     50
50     50
50     50
50     50
50     51
51     51
51     51
51     51
51     52
52     52
52     52
52     52
52     53
53     53
53     53
53     53
53     54
54     54
54     54
54     54
54     55
55     55
55     55
55     55
55     56
56     56
56     56
56     56
56     57
57     57
57     57
57     57
57     58
58     58
58     58
58     58
58     59
59     59
59     59
59     59
59     60
60     60
60     60
60     60
60     61
61     61
61     61
61     61
61     62
62     62
62     62
62     62
62     63
63     63
63     63
63     63
63     64
64     64
64     64
64     64
64     65
65     65
65     65
65     65
65     66
66     66
66     66
66     66
66     67
67     67
67     67
67     67
67     68
68     68
68     68
68     68
68     69
69     69
69     69
69     69
69     70
70     70
70     70
70     70
70     71
71     71
71     71
71     71
71     72
72     72
72     72
72     72
72     73
73     73
73     73
73     73
73     74
74     74
74     74
74     74
74     75
75     75
75     75
75     75
75     76
76     76
76     76
76     76
76     77
77     77
77     77
77     77
77     78
78     78
78     78
78     78
78     79
79     79
79     79
79     79
79     80
80     80
80     80
80     80
80     81
81     81
81     81
81     81
81     82
82     82
82     82
82     82
82     83
83     83
83     83
83     83
83     84
84     84
84     84
84     84
84     85
85     85
85     85
85     85
85     86
85     86
86     86
86     86
86     87
86     87
87     87
87     87
87     88
87     88
88     88
88     88
88     89
88     89
89     89
89     89
89     90
89     90
90     90
90     90
90     91
90     91
91     91
91     91
91     92
91     92
92     92
92     92
92     93
92     93
93     93
93     93
93     94
93     94
94     94
94     94
94     95
94     95
95     95
95     95
95     96
95     96
96     96
96     96
96     97
96     97
97     97
97     97
97     98
97     98
98     98
98     98
98     99
98     99
99     99
99     99
99     100
99     100
100     100
100     100
100     101
100     101
101     101
101     101
101     102
101     102
102     102
...
etc

Ok, found a solution.

This actually makes MAP and DIV by 4 work exactly the same:

/* Map an analog value to 8 bits (0 to 255) */
#include <SoftwareSerial.h>
int val;

void setup() {
  Serial.begin(9600);
  Serial.println("MAP --- DIV4");
}

void loop()
{
  for(int x=0;x<=1023;x++)
  {
    val = map(x, 0, 1024, 0, 256);  //Scales x=0-1023 to val=0-255
    Serial.print(val); //Prints mapped value
    Serial.print("     ");
    Serial.println(x/4); //Prints x/4
  }
}

val = map(x, 0, 1024, 0, 256); //Scales x=0-1023 to val=0-255
This basically makes it divide exactly by 4, instead of 4.0117

I guess Map is my new best friend again.

However, for faster code… use DIV by 4 when scaling A/D to PWM

@nixie:

I don't want to hijack this thread but am interested to know what test using values from analogRead would produce non uniform results with map?

Did BrettW's analysis answer your question?

@BrettW:

I really thought you meant something else, but I just interpreted you wrong. A thousand apologies.

I need to apologize as well. I did the same thing to you in another thread.

Thanks CB!

You are welcome and thank you! Active participation by such a diverse group is one of the things that make this forum such a great place.

Not cool that Map feature...

I agree. If you're interested, there's a fairly complete analysis here (with an opportunity to vote)... http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1257716581

However, for faster code... use DIV by 4 when scaling A/D to PWM

(I hate to do this to you twice in one thread) That may not be true. map is an inline function and the compiler is VERY aggressive at optimizing. It is possible the generated code is identical.

No problem CB. I'm still learning about this stuff myself. I'm a hardware engineer by day, dabble with code on and off work so it's very possible I don't know what the hell I'm talking about. I appreciate you taking the time to steer me and other in the right direction.

I was thinking about my faster statement going to bed last night... A bitshift (2 to the right) and mask with 0xFF would be the fastest for something as simple as divide by 4.

Quick follow-up to my previous message... map is NOT an inline function. BrettW is correct: map is slower than dividing by four which is slower than a shift right.