converteren 10 bit logaritmisch naar 24 bit

Dag iedereen,

Ik ben nog steeds bezig met het ontwerpen van een digitaal mengpaneel met DSP audio processor. Nu het einde in zicht is, ben ik vooral bezig met het schrijven van de code die de besturing doet werken.

De potentiometer waarden worden omgezet van een analoog signaal naar een 10 bit digitaal signaal om die waarden daarna te kunnen schrijven naar een/meerdere register(s). Het probleem hierbij is dat die waarden 24 bit moeten zijn en dat de waarden van mijn potentiometer logaritmisch oplopen en in 10 bit formaat binnenkomen. Hierdoor bemerk ik nu een zeer sterke audio verandering in het laatste deel van de potentio waarden, terwijl de eerste helft gewoon niks doet.

Op welke manier codeer ik deze conversie het best? Rekeninghoudend met de kleine tolerantie die aanwezig kan zijn op de potentiometers vb: min bit waarde 5 max 1020?
Mijn potentiometers zijn 10KOhm.

Alvast bedankt,
Robbe

Ik ben niet zo thuis in programmeren, maar moeten de potmeters niet lineair zijn en wordt het logaritmisch verloop na de ADC met software bewerkstelligd?
Het opslaan van de mechanische stand voor een recall wordt m.i. dan ook veel eenvoudiger.
De tolerantie van de potmeters wordt doorgaans ook met software aangepast. Daarvoor kun je de potmeters via een stukje software calibreren. Dat gebeurt vaak op de uiterste standen en eventueel op het punt waar bijv 0dB bij de fader staat.
Wellicht wist je het al, de potmeters in digitale tafels voeren geen audio en hebben ook maar één weerstandsstrip. Ze geven alleen een dc spanning af aan een ADC. Het audio wordt allemaal geregeld in DSP's.
Deze werkwijze maakt het ook heel eenvoudig om een reeks potmeters te scannen, wat de lay out dan weer vereenvoudigt. Zo heb je niet voor elke potmeter een ADC nodig

Log potmeters zijn hier eigenlijk niet handig, want je verliest resolutie en ze zijn veel minder nauwkeurig maar met tien bits zal het denk ik wel gaan. Het laatste bit zou 20 log (1/1024) = -60 dB zijn, dat is vaak ook de onderkant van de schaal van een fader.
Omzetten naar de gevraagde 24 bits (??) met een eenvoudige look up table en wat interpolatie, rechttrekken per decade oid. Een echte machtsverheffing is duur qua rekentijd en niet nodig.

Voor de calibratie zou ik 0 en -60 dB (of wat ook de laatste waarde voor oneindig is) op de schaal naast de potmeters kiezen, en daaronder muten.
In dit geval zou ik deze herschaling na het omzetten van log-> lin doen.

Ik zou beginnen met een simpele, geknakt lineare benadering:


if (potmeter < 256) {
  volume = (potmeter*3)  <<13;
} else {
  volume = (potmeter+768)<<13;
}

(Eigenlijk is dit wat Aart ook voorsteld, maar dan met slechts een entry in de lookuptable. Eventueel kun je er een tweede of derde elseif tussen zetten.)

@Sparky hieronder: Omdat er best wel veel moderne CPU's zijn waar 4K flash een serieus deel van de storage space is. En als je 10 keer per seconde de volumeknop versteld is het veel, dus vaak hoef je die if/then/elses niet te doen. Maar TS heeft niet verteld welke CPU die gebruikt, dus het is koffiedik kijken.

[Bericht gewijzigd door blurp op (32%)]

Waarom niet gewoon een array met 1024 unsigned longs in flash zetten? Op een moderne CPU is zo'n lookup sneller dan meerdere if/else branches.

Lineaire potmeter => ADC
ADC waarde opdelen in 24 eenheden.
En vervolgens het getal 0x000001 zoveel posities schuiven als het aantal eenheden van de ADC.

Als 1024 entries veel is ... Dan moet je je realiseren dat je bijvoorbeeld over 16 bits gaat schalen. Dan gebruik je de onderste 6 bits voor een table lookup en doe je daarna een rightshift over 15 - <bovenste4bits>

tbl = 2 ^ (23+i/64)
Logres = tbl[v&63] >> (v>>6);

Met v = 0..1023... tabel uitrekenen doe je offline op je pc...

[Bericht gewijzigd door rew op (23%)]