Mixer structural Analysis [Uavcan for example]_php tutorial

Mixer structural Analysis [Uavcan for example]

The mixer instruction is a system app command, located under the Firmware/src/systemcmds/mixer directory, where the function is to load the contents of the mix file into a specific device, and then resolve these definitions by mixergroups in the specific device.
This example is taking Uvacan as an example, after the system runs, the name of the device is:/dev/uavcan/esc.
There are mixergroup instances in the definition of Uavcan, and an output instance.

There are three types of mixer: Nullmixer, simplemixer and Multirotormixer.
Nullmixer: Used for non-grouped output channel points;
Simplemixer: 0 or more inputs fused into one output;
MultirotormixeR: The input amount (roll,pitch,raw,thrusttle) is fused into a set of outputs based on pre-defined geometry.



Functions that read the mix file are located in FIRMWARE/SRC/MODULES/SYSTEMLIB/MIXWR/MIXER_LOAD.C:

The parameter fname is the location of the mix file in the system, buf the buffer for reading the file data, maxlen the maximum length of the BUF.
The function rejects a line that conforms to any of the following:
1. Lines with a line length of less than 2 characters
2. The first character of a line is not an uppercase line
3. The second character is not a line of ': '
After removing the data from these illegal contents, all the remaining formatted content will be stored in the BUF buffer.
So this requires the mix and format to be followed when writing the mix file.
Once these formatted mix contents are read in the buffer, the function

To be handed over to specific equipment for processing.

Definitions of related structures:

 
 

  
  

  
/** Simple Channel Scaler */

  
  

  
struct mixer_scaler_s {

  
  

  
floatnegative_scale;//negative scaling, the mix file O: The 1th integer after the/10000.0f

  
  

  
floatpositive_scale;//forward scaling, in the mix file, O: The 2nd integer after the/10000.0f

  
  

  
Floatoffset; Offset, in the mix file, O: The 3rd integer after the/10000.0f

  
  

  
floatmin_output;//minimum output value, in the mix file, O: The 4th integer after the/10000.0f

  
  

  
floatmax_output;//maximum output value, mix file O: The 5th integer followed by/10000.0f

  
  

  
};//This structure defines the structure of a single control quantity

  
  

  


  
  

  
/** Mixer Input */

  
  

  
struct mixer_control_s {

  
  

  
uint8_tcontrol_group;/**< group from which the input reads */

  
  

  
uint8_tcontrol_index;/**< index within the control group */

  
  

  
struct mixer_scaler_s scaler;/**< scaling applied to the input before use */

  
  

  
};//define the structure of the input amount

  
  

  


  
  

  
/** Simple Mixer */

  
  

  
struct MIXER_SIMPLE_S {

  
  

  
uint8_tcontrol_count;/**< number of inputs */

  
  

  
struct mixer_scaler_soutput_scaler;/**< scaling for the output */

  
  

  
struct mixer_control_scontrols[0];/**< actual size of the array is set by Control_count */

  
  

  
The};//defines the control body of a control entity, including the number of inputs, the input signal control set, and the output signal control.
  
  

  
Because a mixer has only one output and can have 0 to multiple inputs, Control_count indicates the number of input signals required for this mixer, and the specific signals are stored in the array controls[0].
  
  

  
The output is controlled by the Output_scaler.
  
  

  
From the definition of these structures, you can compare the definition of the mix file syntax.

 
 

Uavcan_main.cpp:
The file is parsed with the buffer data mentioned above

1. int Uavcannode::ioctl (file *filp, int cmd, unsigned long arg)
2. {
3. ...
4. Case MIXERIOCLOADBUF: {
   const char *BUF = (const char *) ARG;
   unsigned buflen = Strnlen (buf, 1024);
   
   if (_mixers = = nullptr) {
   _mixers = new Mixergroup (Control_callback, (uintptr_t) _controls);
   }
   
   if (_mixers = = nullptr) {
   _groups_required = 0;
   ret =-enomem;
   
   } else {
   
   ret = _mixers->load_from_buf (buf, Buflen);//start parsing data here
   
   if (ret! = 0) {
   WARNX ("Mixer load failed with%d", ret);
   Delete _mixers;
   _mixers = nullptr;
   _groups_required = 0;
   ret =-einval;
   
   } else {
   
   _mixers->groups_required (_groups_required);
   }
   }
   
   Break
   }
   ...
   
5. }
   

 
 

  
  

  
int mixergroup::load_from_buf (const char *buf, unsigned &buflen)

  
  

  
{

  
  

  
int ret =-1;

  
  

  
const char *end = buf + Buflen;

  
  

  


  
  

  
/*

  
  

  
* Loop until either we have emptied the buffer, or we had failed to

  
  

  
* Allocate something when we expected to.

  
  

  
*/

  
  

  
while (Buflen > 0) {

  
  

  
Mixer *m = nullptr;

  
  

  
const char *p = End-buflen;

  
  

  
unsigned resid = Buflen;

  
  

  


  
  

  
/*

  
  

  
* Use the next character as a hint to decide which mixer class to construct.

  
  

  
*/

  
  

  
Switch (*p) {//First look at the first letter of the line to determine the category of the data.

  
  

  
Case ' Z ':

  
  

  
m = Nullmixer::from_text (P, resid);

  
  

  
Break

  
  

  


  
  

  
Case ' M ':

  
  

  
m = Simplemixer::from_text (_CONTROL_CB, _cb_handle, p, resid);

  
  

  
Break

  
  

  


  
  

  
Case ' R ':

  
  

  
m = Multirotormixer::from_text (_CONTROL_CB, _cb_handle, p, resid);

  
  

  
Break

  
  

  


  
  

  
Default

  
  

  
/* it ' s probably junk or whitespace, skip a byte and retry */

  
  

  
buflen--;

  
  

  
Continue

  
  

  
}

  
  

  


  
  

  
/*

  
  

  
* If We constructed something, add it to the group.

  
  

  
*/

  
  

  
if (m! = nullptr) {

  
  

  
Add_mixer (m);

  
  

  


  
  

  
/* We constructed something */

  
  

  
ret = 0;

  
  

  


  
  

  
/* Only adjust Buflen if parsing is successful */

  
  

  
Buflen = Resid;

  
  

  
Debug ("Success-buflen:%d", buflen);

  
  

  


  
  

  
} else {

  
  

  


  
  

  
/*

  
  

  
* There is data in the buffer and we expected to parse, but it didn ' t,

  
  

  
* So give to now.

  
  

  
*/

  
  

  
Break

  
  

  
}

  
  

  
}

  
  

  


  
  

  
/* Nothing more with the buffer for us now */

  
  

  
return ret;

  
  

  
}
 
 

The following function is used to deal with the definition of the beginning of M: The format specifies that there can be only one number behind the character, which indicates the number of input sources, that is, the number of S type, and the number of struct mixer_control_s that is associated with the definition of the struct.

 
 

  
  

  
Simplemixer *

  
  

  
Simplemixer::from_text (Mixer::controlcallback CONTROL_CB, uintptr_t cb_handle, const char *buf, unsigned &buflen)

  
  

  
{

  
  

  
Simplemixer *sm = nullptr;

  
  

  
mixer_simple_s *mixinfo = nullptr;

  
  

  
unsigned inputs;

  
  

  
int used;

  
  

  
const char *end = buf + Buflen;

  
  

  


  
  

  
/* Get the base info for the mixer * *

  
  

  
if (sscanf (buf, "M:%u%n", &inputs, &used)! = 1) {

  
  

  
Debug ("Simple parse failed on '%s '", buf);

  
  

  
Goto out;

  
  

  
}//copy m: After the first value to the unsigned integer data into the variable inputs, and assign the number of notes already processed to used

  
  

  


  
  

  
BUF = SkipLine (buf, Buflen);//Let buf specify the next line

  
  

  


  
  

  
if (buf = = nullptr) {

  
  

  
Debug ("No Line ending, line is incomplete");

  
  

  
Goto out;

  
  

  
}

  
  

  


  
  

  
Mixinfo = (mixer_simple_s *) malloc (mixer_simple_size (inputs));
  
  

  
M: The number behind is the amount of struct mixer_control_s structure. Mixer_simple_size is the literal meaning of sizeof (mixer_simple_s) + inputs*sizeof (mixer_control_s),
  
  

  
That is, the definition of a complete mixer_simple_s, controls[0] there are inputs altogether.

  
  

  


  
  

  
if (Mixinfo = = nullptr) {

  
  

  
Debug ("Could not allocate memory for mixer info");

  
  

  
Goto out;

  
  

  
}

  
  

  


  
  

  
Mixinfo->control_count = number of inputs;//input signals

  
  

  


  
  

  
if (Parse_output_scaler (End-buflen, Buflen, Mixinfo->output_scaler)) {

  
  

  
Debug ("Simple mixer parser failed parsing out scaler tag, ret: '%s '", buf);

  
  

  
Goto out;

  
  
}//the function resolves the output field and fills the period into the Mixinfo output_scaler field.
 
     
     

  
      
      
int simplemixer::p arse_output_scaler (const char *buf, unsigned &buflen, mixer_scaler_s &scaler)

  
      
      
{

  
      
      
int ret;

  
      
      
int s[5];

  
      
      
int n =-1;

  
      
      


  
      
      
BUF = Findtag (buf, Buflen, ' o ');//Search for "O:" Such a control, return pointer to the output format field defined by the first character ' O '.

 
     
     
    
    

     
     

     
if ((buf = = nullptr) | | (Buflen < 12)) {

     
     

     
Debug ("Output parser failed finding tag, ret: '%s '", buf);

     
     

     
return-1;

     
     

     
}//12, indicating o: the definition of this line has at least 12 characters (O: and five 1-bit long integers), such as the shortest definition: o:0 0 0 0 0

     
     

     


     
     

     
if (ret = sscanf (buf, "O:%d%d%d,%d%d%n",//o: Must be followed by 5 integers, and the integers are separated by at least one space, here is the 5 integer value after the O: Is removed.)

     
     

     
&s[0], &s[1], &s[2], &s[3], &s[4], &n))! = 5) {

     
     

     
Debug ("Out Scaler parse failed on '%s ' (got%d, consumed%d)", buf, RET, n);

     
     

     
return-1;

     
     

     
}

     
     

     


     
     

     
BUF = SkipLine (buf, Buflen);

     
     

     


     
     

     
if (buf = = nullptr) {

     
     

     
Debug ("No Line ending, line is incomplete");

     
     

     
return-1;

     
     

     
}

     
     

     
The following assignment operation allows you to derive the meanings of the 5 values, respectively, [Negative_scale] [Positive_scale] [offset] [min_output] [max_output]
     
     

     
And each of these has been done in addition to 10000 of the operation, so the mix format definition says these values are magnified 10,000 times times after the value.

     
     

     
scaler.negative_scale= S[0]/10000.0f;

     
     

     
scaler.positive_scale= s[1]/10000.0f;

     
     

     
scaler.offset= s[2]/10000.0f;

     
     

     
scaler.min_output= s[3]/10000.0f;

     
     

     
scaler.max_output= s[4]/10000.0f;

     
     

     


     
     

     
return 0;

     
     

     
}
    
    

The above parses the output of the mixer and begins parsing the input as we have read the number of input signals (the value defined in "M:n"), so we loop n times.
  
  

  
First remember the parameters of the Parse_control_scaler function input

  
  

  
for (unsigned i = 0; i < inputs; i++) {

  
  

  
if (Parse_control_scaler (End-buflen, Buflen,

  
  

  
Mixinfo->controls[i].scaler,

  
  

  
Mixinfo->controls[i].control_group,

  
  

  
Mixinfo->controls[i].control_index)) {

  
  

  
Debug ("Simple mixer parser failed parsing CTRL scaler tag, ret: '%s '", buf);

  
  

  
Goto out;

  
  

  
}

  
  

  


  
  
}
    
    

     
     

     
int simplemixer::p arse_control_scaler (const char *buf, unsigned &buflen, mixer_scaler_s &scaler, uint8_t & Control_group,

     
     

     
uint8_t &control_index)

     
     

     
{

     
     

     
unsigned u[2];

     
     

     
int s[5];

     
     

     


     
     

     
BUF = Findtag (buf, Buflen, ' s ');//Find the first ' s ' in the remaining buffer and let BUF point to the beginning of the line;
     
     

     
//

     
     

     
16 indicates that the S: line has at least 16 characters, which is at least 7 integers (because there are at least 1 spaces separated between integers)

     
     

     
if ((buf = = nullptr) | | (Buflen < 16)) {

     
     

     
Debug ("Control parser failed finding tag, ret: '%s '", buf);

     
     

     
return-1;

     
     

     
}

     
     

     
Reads s: 7 integers after the second.

     
     

     
if (sscanf (buf, S:%u%u%d%d%d%d,%d),

     
     

     
&u[0], &u[1], &s[0], &s[1], &s[2], &s[3], &s[4])! = 7) {

     
     

     
Debug ("Control parse failed on '%s '", buf);

     
     

     
return-1;

     
     

     
}

     
     

     


     
     

     
BUF = SkipLine (buf, Buflen);

     
     

     


     
     

     
if (buf = = nullptr) {

     
     

     
Debug ("No Line ending, line is incomplete");

     
     

     
return-1;

     
     

     
}
     
     

     


     
     

     
From the assignment below you can see the mixer file s: The defined format, s: The following integers are
     
     

     
[Control_group] [Ontrol_index] [Negative_scale] [Positive_scale] [offset] [min_output] [max_output]

     
     

     
As can be seen, the definition of the input signal is more than two integers to the definition of the input signal, which is used to indicate the sequence number within the group and group where the current input signal resides. The 1th and 2nd integers are used to
     
     

     
Description group number and group ordinal. The definition of the next 5 integers is the same as the input signal, and is divided by 10000.

     
     

     
control_group= U[0];

     
     

     
control_index= U[1];

     
     

     
scaler.negative_scale= S[0]/10000.0f;

     
     

     
scaler.positive_scale= s[1]/10000.0f;

     
     

     
scaler.offset= s[2]/10000.0f;

     
     

     
scaler.min_output= s[3]/10000.0f;

     
     

     
scaler.max_output= s[4]/10000.0f;

     
     

     


     
     

     
return 0;

     
     

     
}
    
    


 
  
  

  


  
  

  
SM = new Simplemixer (CONTROL_CB, Cb_handle, Mixinfo);

  
  

  


  
  

  
if (sm! = nullptr) {

  
  

  
Mixinfo = nullptr;

  
  

  
Debug ("Loaded mixer with%d input (s)", inputs);

  
  

  


  
  

  
} else {

  
  

  
Debug ("Could not allocate memory for mixer");

  
  

  
}

  
  

  


  
  

  
Out

  
  

  


  
  

  
if (mixinfo! = nullptr) {

  
  

  
Free (mixinfo);

  
  

  
}

  
  

  


  
  

  
return SM;

  
  

  
}
 
 

http://www.bkjia.com/PHPjc/1117247.html www.bkjia.com true http://www.bkjia.com/PHPjc/1117247.html techarticle mixer Structure Analysis [Uavcan for example] mixer instruction is the System App command, located under the Firmware/src/systemcmds/mixer directory, its function is to load the mix file valid content to the specific device ...

