Linearizing an LED for 800 pwm steps'?

[HankMcSpank]

thanks ...i know how to do 256 steps....the problem is it's not enough resolution

I likely need 1024 steps (even a pwm value of 1 has the led quite visible).....at 256 steps a PWM value of 1 is too bright.

I can obviously just use 1024 steps and drive the LED that way ...but without some form of linearizing lookup/data table the LED doesn't fade up/down smoothly (all the brightness action is slanted towards the lower end of the PWM scale)

i've since worked out how to generate the curves I need....but what I still can't figure out is how to put this resulting lookup data into code space.

I read Melanie's "use code space as your playground"....but her syntax relates to PBP assembler....and I'm too clueless to map it to MPASM!

I tried pokecode....but it baulked when the data lookup values got above 255.

Since I can't use Lookup2 .....all I want to do is (for a starter!) get the following 512 lookup values into my program/codespace (my PIC has 7KB of program space ...my program is only about 1800 words...so should be sufficient space to cram list of 512 words in)....

0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,
50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,
96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,
131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,
165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,
199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,
233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,
267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,
301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,
335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,
370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,
405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,
441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,
477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511

Just to give a little more detail wrt the end goal - I'm wanting to take an AD reading & convert it to LED brightness ....I'm using 10 bit ADC...so my intention is to divide the AD result by two then use that AD value to reference the corresponding bit of 512 words in that list ....therefore if incoming AD reading is 760 (10 bit reading)....divide it by 2 to get a 9 bit reading of 380 .....now reference the for 380th entry in that sequence of values ...that'll be the PWM value I need to use.


I've been searching/reading all night & I'm as confused now as whe I started - is this even do-able?

[spcw1234]

Could you do something like this?

ADCvalue var word
x        var byte
duty     var byte

main:
adcin 0, ADCvalue
x=adcvalue/2

if x<256 then lookup x, [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,_
50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,_
96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,_
131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,_
165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,_
199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,_
233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255],duty

if x>255 then lookup x, [256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,_
301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,_
335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,_
370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,_
405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,_
441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,_
477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511],duty

hpwm 1, duty, 1000

goto main

[Jerson]

of course it is do-able. However, I don't think you'll be too happy with the linearity. I am currently working with a similar led lighting problem and know what you're talking about. You need very fine grain at the bottom of the curve to get the intensity variations you need. Shawn has shown an excellent way to split the table lookup into 2 parts.

[HankMcSpank]

Thanks guys, I'm pursung Shawn's method now, a couple of things I've spotted that might need adjustment...

if x>255 then lookup2 x-255, [256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,_
301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,_
335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,_
370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,_
405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,_
441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,_
477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511],duty

In other words, for the second table I think I need to use lookup2 ( as the data in the send group of lookups are words), also I need to take 256 off the index value ....else it's trying to lookup the 256th->512th values in the data list .....but the data list runs 0 thru 255.

Anyway, many thanks....I'll let you know how I get on!

[HankMcSpank]

Boo hiss - No workeee, man cries.

lookup2 only allows up to 85 values in the list. ...I then tried to group all the lookup data I need into blocks of 85 values....but I spontaneously combusted (which gave my wife a bit of a fright)

Any other ideas how to get creative ...I just need to reference at least 512 values in a list (actually, I'd ideally like 1024 values) for a modest 12f1840? (it's got 7kb of program space)

[spcw1234]

What if you keep all the values below 256 and do multiple lookup tables with some simple maths.

ex.

if X<256 then lookup X, [0,...255],duty
if X>255 and X<512 then lookup X-256, [0,...255],duty
if X>511 and X<768 then lookup X-512, [0,...255],duty
if X>767 then lookup X-768, [0,...255],duty

You will loose some resolution in the upper bits, but that is where it doesn't matter for this application.

[HankMcSpank]

but the numbers are non linear ...for example here are the first 256 numbers....

0,0,0,0,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,4,4,4,4,4,4,5,5,5,5,5,5,6,6,6,6,6,7,7,7,7,7,7,
8,8,8,8,8,8,9,9,9,9,9,10,10,10,10,10,10,11,11,11,11,11,12,12,12,12,12,12,13,13,13,13,13,
14,14,14,14,14,15,15,15,15,15,15,16,16,16,16,16,17,17,17,17,17,18,18,18,18,18,19,19,19,
19,19,20,20,20,20,20,21,21,21,21,22,22,22,22,22,23,23,23,23,23,24,24,24,24,24,25,25,25,
25,26,26,26,26,26,27,27,27,27,28,28,28,28,28,29,29,29,29,30,30,30,30,31,31,31,31,31,32,
32,32,32,33,33,33,33,34,34,34,34,35,35,35,35,36,36,36,36,37,37,37,37,38,38,38,38,39,39,39,
39,40,40,40,40,41,41,41,41,42,42,42,43,43,43,43,44,44,44,44,45,45,45,46,46,46,46,47,47,47,
48,48,48,48,49,49,49,50,50,50,50,51,51,51,52,52,52,53,53,53,53,54,54,54,55,55,55,56,56,56,57

& here are the final 256 values I need to look up against...

57,57,58,58,58,59,59,59,59,60,60,60,61,61,62,62,62,63,63,63,64,64,64,65,65,65,66,66,66,67,
67,67,68,68,69,69,69,70,70,70,71,71,72,72,72,73,73,74,74,74,75,75,76,76,76,77,77,78,78,78,
79,79,80,80,80,81,81,82,82,83,83,84,84,84,85,85,86,86,87,87,88,88,89,89,90,90,90,91,91,92,
92,93,93,94,94,95,95,96,96,97,98,98,99,99,100,100,101,101,102,102,103,104,104,105,105,106,
106,107,108,108,109,109,110,111,111,112,113,113,114,114,115,116,116,117,118,118,119,120,
120,121,122,123,123,124,125,125,126,127,128,128,129,130,131,132,132,133,134,135,136,137,
137,138,139,140,141,142,143,144,145,145,146,147,148,149,150,151,152,153,154,155,157,158,
159,160,161,162,163,164,166,167,168,169,171,172,173,175,176,177,179,180,182,183,185,186,188,
189,191,193,194,196,198,200,201,203,205,207,209,211,213,216,218,220,223,225,228,230,233,236,
239,241,245,248,251,255,258,262,266,270,275,279,284,290,295,301,308,315,323,332,341,352,365,
380,398,422,455,512

(so the second tranche are mainly bytes, but a fair few words too)


I don't see how maths can be applied to the numbers like you're suggesting?

here's the vibe I'm try to get (ie the data above plotted on a graph)...

[Darrel Taylor]

lookup2 only allows up to 85 values in the list. ...

That was increased to 1024 in PBP3.
Bug fixes and tweaks:

• Limit on LOOKUP2 item list increased to 1024 for Mid-Range and Enhanced Mid-Range architectures.
• ...

But each value in a LOOKUP2 requires 3 WORDs.
1024 values will use 3K from the 4K available on the 12F1840..

Any other ideas how to get creative ...I just need to reference at least 512 values in a list (actually, I'd ideally like 1024 values) for a modest 12f1840? (it's got 7kb of program space)

This method can store 1024 14-bit values in 1024 words of program space.
http://www.picbasic.co.uk/forum/show...php?t=3891#LAB

[HankMcSpank]

Hi Darrel,

thanks for he info...re the ext modifier, your example in the thread you linked to shows how to store one value in one location, but how would I store many follow on values....do I have to have a huge amount of similar associated lines

GOTO OverData             ; Make sure data doesn't try to execute
ASM
DataTable
    DW  1234h, 2178h     ; etc.
endasm
OverData:

So for example, let's say I want to store eight words, starting at location 2049 of codespace (of my pic12f1840), for example the following values....

256,257,258,259,260,261,262,263,264


what would that look like?

Once I get the overall vibe, then I'm rocking...... :-)