Mixer structure analysis [uavcan as an example] _ PHP Tutorial

Mixer structure analysis [uavcan]. Mixer structure analysis [uavcan as an example] mixer commands are system app commands located in the Firmwaresrcsystemcmdsmixer directory, its function is to load valid content in the mix file to the specific device mixer structure analysis [uavcan as an example]
Mixer commands are system app commands located in the Firmware/src/systemcmds/mixer Directory. the function is to load valid content in the mix file to a specific device, then, the specific device's MixerGroups will parse these definitions.
This example uses uvacan as an example. after the system runs, the device name is/dev/uavcan/esc.
Uavcan defines MixerGroup instances and Output instances.

There are three types of MIXER: NullMixer, SimpleMixer, and MultirotorMixer.
NullMixer: Used for output channel points not grouped;
SimpleMixer: Zero or multiple inputs are combined into one output;
MultirotorMixeR: combine the inputs (ROLL, PITCH, RAW, Thrusttle) into a set of outputs based on predefined geometry.



The function used to read the mix file is located in Firmware/src/modules/systemlib/mixwr/mixer_load.c:

 
 

  
  
int load_mixer_file(const char *fname, char *buf, unsigned maxlen) 
 
 

The fname parameter is the position of the mix file in the system. buf is the buffer for reading file data and maxlen is the maximum length of the buf.
This function will remove the rows that match any of the following:
1. rows with a length less than 2 characters
2. the first character of a row is not a line with uppercase letters
3. the second character is not a ':' line
After the data of the illegal content is removed, all the remaining formatted content will be stored in the buf buffer.
Therefore, you must follow the mix and format when writing a mix file.
After the formatted mix content is read from the buffer

 
 

  
  
int ret = ioctl(dev, MIXERIOCLOADBUF, (unsigned long)buf); 
 
 

To specific devices.

Definitions of related structures:

 
 

  
  
/** Simple channel scaler */
 
  
  
Struct mixer_scaler_s {

  
  
Floatnegative_scale; // negative scaling. in the MIX file, O: The Next 1st integers/10000.0f

  
  
Floatpositive_scale; // forward scaling. in the MIX file, O: The Next 2nd integers/limit f

  
  
Floatoffset; // Offset. in the MIX file, "O": the first integer after "/until F ".

  
  
Floatmin_output; // minimum output value. in the MIX file, "O" indicates the next 4th integers/limit f.

  
  
Floatmax_output; // maximum output value. in the MIX file, "O" indicates the next 5th integers/limit f.

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

  
  


  
  
/** 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 input volume structure

  
  


  
  
/** 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 */

  
  
}; // Defines a control entity, including the number of input signals, input signal control set, and 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 by this mixer, the specific signals are stored in the array controls [0.
  
  
// Output is controlled by output_scaler.
  
  
// The definition of these struct can be compared with the syntax definition of the mix file.
 
 
 

Uavcan_main.cpp:
This file parses 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;
   Unsignebuflen = 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); // Parse 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 have failed

  
  
* Allocate something when we expected.

  
  
*/

  
  
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 check the first letter of the row to determine the data category.

  
  
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 was successful */

  
  
Buflen = resid;

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

  
  


  
  
} Else {

  
  


  
  
/*

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

  
  
* So give up for now.

  
  
*/

  
  
Break;

  
  
}

  
  
}

  
  


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

  
  
Return ret;

  
  
}
 
 

The following function is used to process the definition starting with "M". the format specifies that only one number is followed by the character to specify the number of input signal sources, that is, the number of S-type numbers, the number of struct mixer_control_s associated with the struct definition.

 
 

  
  
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: The first value to the unsigned integer data to the variable inputs, and assign the number of processed notes to used.

  
  


  
  
Buf = skipline (buf, buflen); // you can specify the next row for the buf.

  
  


  
  
If (buf = nullptr ){

  
  
Debug ("no line ending, line is incomplete ");

  
  
Goto out;

  
  
}

  
  


  
  
Mixinfo = (mixer_simple_s *) malloc (MIXER_SIMPLE_SIZE (inputs ));
  
  
// M: the following number is the number of the struct mixer_control_s structure. the MIXER_SIMPLE_SIZE field is sizeof (mixer_simple_s) + inputs * sizeof (mixer_control_s ),
  
  
// It is a complete definition of mixer_simple_s. controls [0] has a total of inputs.
 
  
  


  
  
If (mixinfo = nullptr ){

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

  
  
Goto out;

  
  
}

  
  


  
  
Mixinfo-> control_count = inputs; // number of 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;

  
  
} // This function parses the output field and fills the period in the output_scaler field of mixinfo.
    
    

     
     
Int SimpleMixer: parse_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 a controller like "O:". return the pointer pointing to the first character 'o' defined in the output format domain '.

    
    
    
    

     
     
If (buf = nullptr) | (buflen <12 )){

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

     
     
Return-1;

     
     
} // 12, indicating that the O: line must have at least 12 characters (O: and five 1-digit long integers). For example, the shortest is defined as: O: 0 0 0 0 0

     
     


     
     
If (ret = sscanf (buf, "O: % d % n", // O: five integers must be followed, and the integers are separated by at least one space. Here we take out O: The next five integers.

     
     
& 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;

     
     
}

     
     
// From the following assignment operation, we can obtain O: The meaning of the next five values, which are [negative_scale] [positive_scale] [offset] [min_output] [max_output]
     
     
// And each operation except 10000 is performed, so the values in the MIX format definition are all values after 10000 times.
 
     
     
Scaler. negative_scale = s [0]/1_f;

     
     
Scaler. positive_scale = s [1]/1_f;

     
     
Scaler. offset = s [2]/limit F;

     
     
Scaler. min_output = s [3]/limit F;

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

     
     


     
     
Return 0;

     
     
}
    
    

// The output of MIXER is parsed above, and the input is parsed below, because we have read the number of input signals (the value defined by n in "M: n ), so it takes n cycles.
  
  
// First, remember the parameters input by the parse_control_scaler function.
 
  
  
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: parse_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 '); // locate the first 's' in the remaining buffer and point the buf to the first row of the row;
     
     
//
 
     
     
// 16 indicates the value of S: The row must contain at least 16 characters, that is, at least 7 integers (because integers are separated by at least one space)

     
     
If (buf = nullptr) | (buflen <16 )){

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

     
     
Return-1;

     
     
}

     
     
// Read S: the next 7 integers.

     
     
If (sscanf (buf, "S: % u % 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 following assignment, we can see that the MIXER File S: defined format, and S: the integers following them are
     
     
// [Control_group] [ontrol_index] [negative_scale] [positive_scale] [offset] [min_output] [max_output]
 
     
     
// It can be seen that the definition of the input signal is two integers more than the definition of the input and output signals, indicating the group where the current input signal is located and the number of the group. 1st and 2nd are used.
     
     
// Indicates the group number and the group number. the definitions of the last five integers are the same as those of the input signal, and must be divided by 10000.
 
     
     
Control_group = u [0];

     
     
Control_index = u [1];

     
     
Scaler. negative_scale = s [0]/1_f;

     
     
Scaler. positive_scale = s [1]/1_f;

     
     
Scaler. offset = s [2]/limit F;

     
     
Scaler. min_output = s [3]/limit F;

     
     
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 ("cocould not allocate memory for mixer ");

  
  
}

  
  


  
  
Out:

  
  


  
  
If (mixinfo! = Nullptr ){

  
  
Free (mixinfo );

  
  
}

  
  


  
  
Return sm;

  
  
}
 
 

Http://www.bkjia.com/PHPjc/1117247.htmlwww.bkjia.comtruehttp://www.bkjia.com/PHPjc/1117247.htmlTechArticlemixer structure analysis [uavcan for example] mixer command is the system app command, in the Firmware/src/systemcmds/mixer Directory, its function is to load valid content in the mix file to a specific device...