Сбор и анализ данных акселерометра робота

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.

void Transfer_ADCBuffer(unsigned int num_bytes) { unsigned int n; SFRPAGE = UART0_PAGE; SCON0_TI = 0; //make sure that the transmit interrupt flag is cleared for(n=0; n

The ADC is configured to sequentially sample from P1.5, then P1.6, then P1.7, back to P1.5, and so forth.

As you can see from the schematic, this results in data that is arranged in memory as follows: z-axis, y-axis, x-axis, z-axis, y-axis, x-axis, and so forth. The ADC is configured for big endian, which means that each sample will begin with the high byte. Thus, our memory looks like this:

YAT If everything is working correctly, the ADC data will appear in the YAT window. Here is what you need to do to make it very easy to inspect this data and work with it in Excel: Go to Terminal->Settings and select "Binary" for "Terminal Type." In the same window, click "Binary Settings"; check the box for "Separate settings for Tx and Rx" then enter "6" for "Break lines after" in the "Rx" section.

Back in the main window, click on the "10" button so that the data appears as decimal

Now when you transfer the data, it will appear as follows:

This is the format we want: each row consists of one data point, ie, one two-byte sample for each acceleration axis. Excel First, save the YAT data to a file:

Now you can import this space-separated data into Excel using the "From Text" button in the "Data" ribbon. Note that this block of data will remain "connected" to the data file, so to bring in new data you simply use the "refresh" functionality (see the video below for a demonstration). Once you have the raw data in Excel, you can convert it to ADC counts and to volts (or millivolts). I have my worksheet set up like this:

Click to enlarge On a separate sheet, I have a plot that pulls data from the "millivolts" columns. If you want to use my Excel file, feel free: Excel File

Here is a plot of "self-test" output signals (you can read about the self-test functionality in the ADXL326 datasheet).

(The initial rising edge is a result of the accelerometer's startup delay.) Self-test causes the analog outputs to assume a predetermined value; if the measured voltages correspond to the expected voltages, you know that the accelerometer is functional. And because the predetermined value is different for each axis, self-test allows you to confirm that you are associating the samples with the correct axis. Here are plots for two more data sets. In the first, the PCB is not moving; in the second, I am using my hand to jiggle the robot chassis.

The following video helps to clarify the overall procedure:

Summary We discussed the hardware implementation of a three-axis, analog-output accelerometer, and I presented a straightforward method of getting stored accelerometer data from the robot's microcontroller to a PC. We then moved the data into Excel and plotted the results.