Сакупљање и анализа података о роботском акцелерометру

The Great Gildersleeve: Gildy's New Car / Leroy Has the Flu / Gildy Needs a Hobby (Јули 2019).

$config[ads_text] not found
Anonim

Сакупљање и анализа података о роботском акцелерометру


Акцелерометар може бити драгоцен додатак у пројекту роботике. Овај чланак ће вам показати један приступ у генерисању и анализирању података о убрзању.

Подршка информације

  • Дизајнирајте одбор за програмирање и тестирање прилагођених микроконтролера
  • Прилагођени ПЦБ дизајн са ЕФМ8 микроконтролером
  • Дизајнирајте контролну плочу за шасију Роми робота

Акцелерометар

У претходном чланку сам представио шасију Роми робота из Пололуа и ромски контролни ПЦБ. Можете да користите следећу везу да бисте преузели комплетну схему и БОМ.

Шематски и БОМ

Овај ПЦБ укључује, између осталог, акцелерометар. Део који сам изабрао је АДКСЛ326 из Аналог Девицес. То је троосовински, аналогни излазни уређај и, из перспективе корисника, то уопште није компликовано. Као што видите, потребно је неколико спољних компоненти:

Моје капице су (номинално) 0, 022 μФ, тако да на основу табеле изнад мој пропусни опсег буде нешто већи од 200 Хз.

Следећи дијаграм преноси упуте АДКСЛ326 к, и и з.

Ако комбинујемо ову оријентацију са дијаграмом података и правцима кретања робота како је овде дефинисано, то можемо утврдити

  • напредни смјер робота одговара негативном убрзању к-оса,
  • обратни смер одговара позитивном убрзању к оси,
  • десни смер одговара позитивном убрзању осовине и,
  • а леви смер одговара негативном убрзању и оси.

АДЦ

Користићемо аналогни-дигитални претварач ЕФМ8 за дигитализацију три аналогна сигнала убрзања која генерише АДКСЛ326. Користићемо пуну 14-битну резолуцију и интерно генерисану референцу од 2.4 В. Можете се позвати на конфигурациону датотеку хардвера и изворну датотеку АДЦ.ц за детаље конфигурације АДЦ-а; ове, заједно са свим осталим изворним и пројектним датотекама, могу се преузети кликом на следећи линк:

Изворни и пројектни фајлови

Ако погледате целу схему, приметићете да су излазни сигнали акцелерометра директно повезани на АДЦ улазе. Ниједан анти-алиасинг филтер није потребан јер ограничење пропусног опсега постиже се низим пасусним филтером који је горе описан и прилично сам сигуран да нам не треба пратилац напона, јер АДЦ модул има модул за избјегавање слабљења који вероватно укључује неке врста кола која резултира малом излазном импеданцијом.

Користићемо АДЦ функцију аутосцан за сакупљање 2400 бајта података АДЦ-а. Сваки узорак захтева два бита и имамо три канала (за три оси), и стога имамо (2400/2) / 3 = 400 узорака по оси.

Пренос података

Морамо дати податке о убрзању на рачунар за визуелизацију и анализу. У прошлости сам користио микроконтролер са УСБ-ом у комбинацији с прилагођеном Сцилаб скриптом (погледајте овај чланак, укључујући и линкове у одељку "Подршка информација"). Међутим, одлучио сам да пређем на једноставнији и разноврснији систем. Претходни приступ сигурно има предности, али је рестриктиван (јер морате користити микроконтролер са УСБ функционалношћу) и компликовано (због додатног УСБ фирмваре-а и читавог развоја Сцилаб-а).

Нови метод се ослања на ИАТ (програм "Још један терминал") и Екцел. Претпостављам да би се могао користити други програм за рад са табелама, али упуте овдје су специфичне за Екцел.

Ценим једноставност УАРТ комуникације, али рачунари немају више серијских портова. Најједноставнији лек за ову ситуацију је УСБ-то-УАРТ конвертор; Ја користим овај од Полола. То је у суштини плоча за ЦП2104 из Силицон Лабс-а; Могао сам да дизајнирам свој, али ако Пололу прода своје $ 5, 95, зашто се мучи. Ова практична мала плоча дозвољава ми да напишем фирмваре као да УСБ не постоји - само пошаљите бајт, примите бајт, као у добрим старим данима РС-232. Следећа слика показује ПЦИ контролну плочу повезан са Ц2 адаптером плоча са десне стране и УСБ-то-УАРТ претварач с леве стране.

Напомена: Ако напајате плочу са УСБ-а, требало би да се уверите да ваш код не дозвољава да мотори буду омогућени. УСБ портови нису дизајнирани за такву врсту текућег извлачења. Препоручујем да физички искључите моторе, само да будете сигурни.

Када АДЦ заврши 1200 узорака (400 по оси), једноставно напишемо сваки бајт из серијског порта на следећи начин:

 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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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. 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. Now when you transfer the data, it will appear as follows: 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: (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.

Стручни Савети

Размена Искустава