unit_main.c

Go to the documentation of this file.
00001 /*
00002 # This file is Copyright 2007, 2009 Dean Hall.
00003 #
00004 # This file is part of the Python-on-a-Chip program.
00005 # Python-on-a-Chip is free software: you can redistribute it and/or modify
00006 # it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1.
00007 # 
00008 # Python-on-a-Chip is distributed in the hope that it will be useful,
00009 # but WITHOUT ANY WARRANTY; without even the implied warranty of
00010 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00011 # A copy of the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1
00012 # is seen in the file COPYING up one directory from this.
00013 */
00014 
00025 #ifndef __PIC24HJ128GP504__
00026 #error These unit tests are desgined to work only on the PIC24HJ128GP504.
00027 #endif
00028 
00029 #include "pm.h"
00030 #include "pic24_all.h"
00031 #include "CuTestSmall.h"
00032 #include "pyFuncsInC.h"
00033 #include <pps.h>
00034 
00035 
00036 /* Need to declare this array since no PyMite application is linked */
00037 pPmNativeFxn_t const usr_nat_fxn_table[];
00038 
00042 void test_gpioExists(CuTest* tc)
00043 {
00044     // The PIC24HJxxGP504 is a 44 pin chip with 3 IO ports
00045     CuAssertTrue(tc, NUM_DIGITAL_PORTS == 3);
00046 
00047     // It has remappable pins
00048 #ifndef HAS_REMAPPABLE_PINS
00049     CuAssertTrue(tc, 0);
00050 #endif
00051 
00052     // Spot check simple port / pin existance
00053     CuAssertTrue(tc, !digitalPinInBounds(PORT_A_INDEX, 16));
00054     CuAssertTrue(tc, !digitalPinInBounds(PORT_D_INDEX, 0));
00055     CuAssertTrue(tc,  digitalPinInBounds(PORT_C_INDEX, 15));
00056 
00057     // Check specific port / pin combos:
00058     // Port A
00059     CuAssertTrue(tc,  digitalPinExists(PORT_A_INDEX, 0));
00060     CuAssertTrue(tc,  digitalPinExists(PORT_A_INDEX, 1));
00061     CuAssertTrue(tc,  digitalPinExists(PORT_A_INDEX, 2));
00062     CuAssertTrue(tc,  digitalPinExists(PORT_A_INDEX, 3));
00063     CuAssertTrue(tc,  digitalPinExists(PORT_A_INDEX, 4));
00064     CuAssertTrue(tc, !digitalPinExists(PORT_A_INDEX, 5));
00065     CuAssertTrue(tc, !digitalPinExists(PORT_A_INDEX, 6));
00066     CuAssertTrue(tc,  digitalPinExists(PORT_A_INDEX, 7));
00067     CuAssertTrue(tc,  digitalPinExists(PORT_A_INDEX, 8));
00068     CuAssertTrue(tc,  digitalPinExists(PORT_A_INDEX, 9));
00069     CuAssertTrue(tc,  digitalPinExists(PORT_A_INDEX, 10));
00070     CuAssertTrue(tc, !digitalPinExists(PORT_A_INDEX, 11));
00071     CuAssertTrue(tc, !digitalPinExists(PORT_A_INDEX, 12));
00072     CuAssertTrue(tc, !digitalPinExists(PORT_A_INDEX, 13));
00073     CuAssertTrue(tc, !digitalPinExists(PORT_A_INDEX, 14));
00074     CuAssertTrue(tc, !digitalPinExists(PORT_A_INDEX, 15));
00075     // Port B
00076     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 0));
00077     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 1));
00078     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 2));
00079     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 3));
00080     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 4));
00081     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 5));
00082     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 6));
00083     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 7));
00084     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 8));
00085     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 9));
00086     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 10));
00087     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 11));
00088     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 12));
00089     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 13));
00090     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 14));
00091     CuAssertTrue(tc,  digitalPinExists(PORT_B_INDEX, 15));
00092     // Port C
00093     CuAssertTrue(tc,  digitalPinExists(PORT_C_INDEX, 0));
00094     CuAssertTrue(tc,  digitalPinExists(PORT_C_INDEX, 1));
00095     CuAssertTrue(tc,  digitalPinExists(PORT_C_INDEX, 2));
00096     CuAssertTrue(tc,  digitalPinExists(PORT_C_INDEX, 3));
00097     CuAssertTrue(tc,  digitalPinExists(PORT_C_INDEX, 4));
00098     CuAssertTrue(tc,  digitalPinExists(PORT_C_INDEX, 5));
00099     CuAssertTrue(tc,  digitalPinExists(PORT_C_INDEX, 6));
00100     CuAssertTrue(tc,  digitalPinExists(PORT_C_INDEX, 7));
00101     CuAssertTrue(tc,  digitalPinExists(PORT_C_INDEX, 8));
00102     CuAssertTrue(tc,  digitalPinExists(PORT_C_INDEX, 9));
00103     CuAssertTrue(tc, !digitalPinExists(PORT_C_INDEX, 10));
00104     CuAssertTrue(tc, !digitalPinExists(PORT_C_INDEX, 11));
00105     CuAssertTrue(tc, !digitalPinExists(PORT_C_INDEX, 12));
00106     CuAssertTrue(tc, !digitalPinExists(PORT_C_INDEX, 13));
00107     CuAssertTrue(tc, !digitalPinExists(PORT_C_INDEX, 14));
00108     CuAssertTrue(tc, !digitalPinExists(PORT_C_INDEX, 15));
00109 }
00110 
00123 void test_gpioOdExists(CuTest* tc)
00124 {
00125     // Test open-drain config
00126     // Port A
00127 #if 0   // Test everything we can be commenting these out for now
00128     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 0));
00129     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 1));
00130     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 2));
00131     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 3));
00132     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 4));
00133 #endif
00134     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 5));
00135     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 6));
00136     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_A_INDEX, 7));
00137     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_A_INDEX, 8));
00138     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_A_INDEX, 9));
00139     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_A_INDEX, 10));
00140     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 11));
00141     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 12));
00142     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 13));
00143     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 14));
00144     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 15));
00145     // Port B
00146 #if 0
00147     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_B_INDEX, 0));
00148     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_B_INDEX, 1));
00149     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_B_INDEX, 2));
00150     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_B_INDEX, 3));
00151     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_B_INDEX, 4));
00152 #endif
00153     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_B_INDEX, 5));
00154     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_B_INDEX, 6));
00155     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_B_INDEX, 7));
00156     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_B_INDEX, 8));
00157     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_B_INDEX, 9));
00158     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_B_INDEX, 10));
00159     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_B_INDEX, 11));
00160     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_B_INDEX, 12));
00161     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_B_INDEX, 13));
00162     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_B_INDEX, 14));
00163     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_B_INDEX, 15));
00164     // Port C
00165 #if 0
00166     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_C_INDEX, 0));
00167     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_C_INDEX, 1));
00168     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_C_INDEX, 2));
00169 #endif
00170     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_C_INDEX, 3));
00171     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_C_INDEX, 4));
00172     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_C_INDEX, 5));
00173     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_C_INDEX, 6));
00174     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_C_INDEX, 7));
00175     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_C_INDEX, 8));
00176     CuAssertTrue(tc,  digitalOpenDrainPinExists(PORT_C_INDEX, 9));
00177     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_C_INDEX, 10));
00178     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_C_INDEX, 11));
00179     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_C_INDEX, 12));
00180     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_C_INDEX, 13));
00181     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_C_INDEX, 14));
00182     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_C_INDEX, 15));
00183     
00184     // For future testing, include one failure; fixing this should
00185     // allow including all the unincluded code above.
00186     CuAssertTrue(tc, !digitalOpenDrainPinExists(PORT_A_INDEX, 0));
00187 }
00188 
00192 void test_gpioSetPinIsInput(CuTest* tc)
00193 {
00194     // An exception should be thrown in an invalid port / pin
00195     CuAssertTrue(tc, setPinIsInput(PORT_A_INDEX, 5, C_TRUE) == PM_RET_EX_VAL);
00196 
00197     // Check than configuring a specific pin as an input does indeed change
00198     // the pin's TRIS value.
00199     _TRISA0 = 0;
00200     CuAssertTrue(tc, setPinIsInput(PORT_A_INDEX, 0, C_TRUE) == PM_RET_OK);
00201     CuAssertTrue(tc, _TRISA0 == 1);
00202     _TRISA0 = 1;
00203     CuAssertTrue(tc, setPinIsInput(PORT_A_INDEX, 0, C_FALSE) == PM_RET_OK);
00204     CuAssertTrue(tc, _TRISA0 == 0);
00205 }
00206 
00210 void test_gpioGetPinIsInput(CuTest* tc)
00211 {
00212     bool_t b_isInput;
00213 
00214     // An exception should be thrown in an invalid port / pin
00215     CuAssertTrue(tc, getPinIsInput(PORT_A_INDEX, 5, &b_isInput) == PM_RET_EX_VAL);
00216 
00217     // Check than configuring a specific pin as an input does indeed change
00218     // the pin's TRIS value.
00219     _TRISA0 = 0;
00220     b_isInput = C_TRUE;
00221     CuAssertTrue(tc, getPinIsInput(PORT_A_INDEX, 0, &b_isInput) == PM_RET_OK);
00222     CuAssertTrue(tc, !b_isInput);
00223     _TRISA0 = 1;
00224     b_isInput = C_FALSE;
00225     CuAssertTrue(tc, getPinIsInput(PORT_A_INDEX, 0, &b_isInput) == PM_RET_OK);
00226     CuAssertTrue(tc, b_isInput);
00227 }
00228 
00232 void test_gpioSetPinIsDigital(CuTest* tc)
00233 {
00234     // An exception should be thrown in an invalid port / pin
00235     CuAssertTrue(tc, setPinIsDigital(PORT_A_INDEX, 5, C_TRUE) == PM_RET_EX_VAL);
00236 
00237     // Configuring a pin with no analog capability as digital should always
00238     // work (and do nothing)
00239     CuAssertTrue(tc, setPinIsDigital(PORT_A_INDEX, 2, C_TRUE) == PM_RET_OK);
00240 
00241     // Configuring a pin with no analog capability as analog should always
00242     // fail and report an exception
00243     CuAssertTrue(tc, setPinIsDigital(PORT_A_INDEX, 2, C_FALSE) == PM_RET_EX_VAL);
00244 
00245     // Test the PCFG bit when configuring a pin with analog capability
00246     _PCFG0 = 0;
00247     CuAssertTrue(tc, setPinIsDigital(PORT_A_INDEX, 0, C_TRUE) == PM_RET_OK);
00248     CuAssertTrue(tc, _PCFG0 == 1);
00249     _PCFG0 = 1;
00250     CuAssertTrue(tc, setPinIsDigital(PORT_A_INDEX, 0, C_FALSE) == PM_RET_OK);
00251     CuAssertTrue(tc, _PCFG0 == 0);
00252 }
00253 
00257 void test_gpioSetPinIsOpenDrain(CuTest* tc)
00258 {
00259     // An exception should be thrown in an invalid port / pin
00260     CuAssertTrue(tc, setPinIsOpenDrain(PORT_A_INDEX, 5, C_TRUE) == PM_RET_EX_VAL);
00261 
00262     // Configuring a pin with no open-drain capability as non-OD should always
00263     // work (and do nothing)
00264     CuAssertTrue(tc, setPinIsOpenDrain(PORT_A_INDEX, 0, C_FALSE) == PM_RET_OK);
00265 
00266     // Configuring a pin with no open-drain capability as OD should always
00267     // fail and report an exception
00268     CuAssertTrue(tc, setPinIsOpenDrain(PORT_A_INDEX, 0, C_TRUE) == PM_RET_EX_VAL);
00269 
00270     // Test the PCFG bit when configuring a pin with analog capability
00271     _ODCA7 = 0;
00272     CuAssertTrue(tc, setPinIsOpenDrain(PORT_A_INDEX, 7, C_TRUE) == PM_RET_OK);
00273     CuAssertTrue(tc, _ODCA7 == 1);
00274     _ODCA7 = 1;
00275     CuAssertTrue(tc, setPinIsOpenDrain(PORT_A_INDEX, 7, C_FALSE) == PM_RET_OK);
00276     CuAssertTrue(tc, _ODCA7 == 0);
00277 }
00278 
00282 void test_gpioSetPinPullDirection(CuTest* tc)
00283 {
00284     // An exception should be thrown in an invalid port / pin
00285     CuAssertTrue(tc, setPinPullDirection(PORT_A_INDEX, 5, 0) == PM_RET_EX_VAL);
00286 
00287     // Configuring a pin with no pull-up capability as non-PU should always
00288     // work (and do nothing)
00289     CuAssertTrue(tc, setPinPullDirection(PORT_A_INDEX, 8, 0) == PM_RET_OK);
00290 
00291     // Configuring a pin with no pull-up capability as PU should always
00292     // fail and report an exception
00293     CuAssertTrue(tc, setPinPullDirection(PORT_A_INDEX, 8, 1) == PM_RET_EX_VAL);
00294 
00295     // Configuring a pin with no pull-down capability as PD should always
00296     // fail and report an exception
00297     CuAssertTrue(tc, setPinPullDirection(PORT_A_INDEX, 8, -1) == PM_RET_EX_VAL);
00298     // Same for a pin with pull-up but not pull-down
00299     CuAssertTrue(tc, setPinPullDirection(PORT_A_INDEX, 0, -1) == PM_RET_EX_VAL);
00300 
00301     // Test the PCFG bit when configuring a pin with analog capability
00302     _CN2PUE = 0;
00303     CuAssertTrue(tc, setPinPullDirection(PORT_A_INDEX, 0, 1) == PM_RET_OK);
00304     CuAssertTrue(tc, _CN2PUE == 1);
00305     _CN2PUE = 1;
00306     CuAssertTrue(tc, setPinPullDirection(PORT_A_INDEX, 0, 0) == PM_RET_OK);
00307     CuAssertTrue(tc, _CN2PUE == 0);
00308 }
00309 
00313 void test_gpioUnmapPin(CuTest* tc)
00314 {
00315     // This chip has remappable pins
00316 #ifndef HAS_REMAPPABLE_PINS
00317     CuAssertTrue(tc, 0);
00318 #endif
00319     // An exception should be thrown in an invalid port / pin
00320     CuAssertTrue(tc, unmapPin(PORT_A_INDEX, 5) == PM_RET_EX_VAL);
00321 
00322     // Unmapping an unmappable pin should do nothing and return success
00323     CuAssertTrue(tc, unmapPin(PORT_A_INDEX, 0) == PM_RET_OK);
00324 
00325     // Map an input, then test the unmap
00326     _U1RXR = 0;
00327     CuAssertTrue(tc, unmapPin(PORT_B_INDEX, 0) == PM_RET_OK);
00328     CuAssertTrue(tc, _U1RXR == IN_PIN_PPS_VSS);
00329 
00330     // Map an output, then test the unmap
00331     _RP0R = 3;  // U1TX
00332     CuAssertTrue(tc, unmapPin(PORT_B_INDEX, 0) == PM_RET_OK);
00333     CuAssertTrue(tc, _RP0R == OUT_FN_PPS_NULL);
00334 }
00335 
00339 void
00340 test_gpioSetDigitalPin(CuTest* tc)
00341 {
00342     // An exception should be thrown in an invalid port / pin
00343     CuAssertTrue(tc, setDigitalPin(PORT_A_INDEX, 5, C_TRUE) == PM_RET_EX_VAL);
00344 
00345     // Test setting a pin true and false
00346     _LATA0 = 0;
00347     CuAssertTrue(tc, setDigitalPin(PORT_A_INDEX, 0, C_TRUE) == PM_RET_OK);
00348     CuAssertTrue(tc, _LATA0 == 1);
00349     CuAssertTrue(tc, setDigitalPin(PORT_A_INDEX, 0, C_FALSE) == PM_RET_OK);
00350     CuAssertTrue(tc, _LATA0 == 0);
00351 }
00352 
00356 void
00357 test_gpioReadDigitalPin(CuTest* tc)
00358 {
00359     // An exception should be thrown in an invalid port / pin
00360     bool_t b_pin;
00361     CuAssertTrue(tc, readDigitalPin(PORT_A_INDEX, 5, &b_pin) == PM_RET_EX_VAL);
00362 
00363     // Test setting a pin true and false
00364     // Make RA0 an output, then set its value and read that value back.
00365     configDigitalPin(PORT_A_INDEX, 0, C_FALSE, C_FALSE, 0);
00366     _LATA0 = 1;
00367     CuAssertTrue(tc, readDigitalPin(PORT_A_INDEX, 0, &b_pin) == PM_RET_OK);
00368     CuAssertTrue(tc, b_pin);
00369     _LATA0 = 0;
00370     CuAssertTrue(tc, readDigitalPin(PORT_A_INDEX, 0, &b_pin) == PM_RET_OK);
00371     CuAssertTrue(tc, !b_pin);
00372 }
00373 
00377 void
00378 test_gpioReadDigitalLatch(CuTest* tc)
00379 {
00380     // An exception should be thrown in an invalid port / pin
00381     bool_t b_pin;
00382     CuAssertTrue(tc, readDigitalLatch(PORT_A_INDEX, 5, &b_pin) == PM_RET_EX_VAL);
00383 
00384     // Test setting a pin true and false
00385     _LATA0 = 1;
00386     CuAssertTrue(tc, readDigitalLatch(PORT_A_INDEX, 0, &b_pin) == PM_RET_OK);
00387     CuAssertTrue(tc, b_pin);
00388     _LATA0 = 0;
00389     CuAssertTrue(tc, readDigitalLatch(PORT_A_INDEX, 0, &b_pin) == PM_RET_OK);
00390     CuAssertTrue(tc, !b_pin);
00391 }
00392 
00396 void
00397 test_configDigitalPin(CuTest* tc)
00398 {
00399     // Config a pin and check results
00400     CuAssertTrue(tc, configDigitalPin(PORT_B_INDEX, 1, C_FALSE, C_FALSE, 0) == PM_RET_OK);
00401     CuAssertTrue(tc, _PCFG3 == 1);
00402     CuAssertTrue(tc, _TRISB1 == 0);
00403     CuAssertTrue(tc, _ODCB1 == 0);
00404     CuAssertTrue(tc, _CN5PUE == 0);
00405 
00406     // Config with opposite params and check
00407     CuAssertTrue(tc, configDigitalPin(PORT_B_INDEX, 1, C_TRUE, C_TRUE, 1) == PM_RET_OK);
00408     CuAssertTrue(tc, _PCFG3 == 1);
00409     CuAssertTrue(tc, _TRISB1 == 1);
00410     CuAssertTrue(tc, _ODCB1 == 1);
00411     CuAssertTrue(tc, _CN5PUE == 1);
00412 
00413 }
00417 void
00418 test_configAnalogPin(CuTest* tc)
00419 {
00420     // An exception should bethrown for an invalid analog pin
00421     CuAssertTrue(tc, configAnalogPin(13) == PM_RET_EX_VAL);
00422 
00423     // Config RA0 / AN0 as a digital output
00424     CuAssertTrue(tc, configDigitalPin(PORT_A_INDEX, 0, C_FALSE, C_FALSE, 1) == PM_RET_OK);
00425     // Now make it an analog input
00426     CuAssertTrue(tc, configAnalogPin(0) == PM_RET_OK);
00427     CuAssertTrue(tc, _PCFG0 == 0);
00428     CuAssertTrue(tc, _CN2PUE == 0);
00429     CuAssertTrue(tc, _TRISA0 == 1);
00430 }
00431 
00435 void
00436 test_configPwm(CuTest* tc)
00437 {
00438     // An exception should be thrown for an invalid OC pin
00439     //                         u32_freq, b_isTimer2, u16_oc, i16_ocPin)
00440     CuAssertTrue(tc, configPwm(1000,     C_TRUE,     1,      -1) == PM_RET_EX_VAL);
00441     CuAssertTrue(tc, configPwm(1000,     C_TRUE,     1,      26) == PM_RET_EX_VAL);
00442 
00443     // An exception should be thrown for an invalid OC peripheral
00444     //                         u32_freq, b_isTimer2, u16_oc, i16_ocPin)
00445     CuAssertTrue(tc, configPwm(1000,     C_TRUE,     -1,     0) == PM_RET_EX_VAL);
00446     CuAssertTrue(tc, configPwm(1000,     C_TRUE,     0,      0) == PM_RET_EX_VAL);
00447     CuAssertTrue(tc, configPwm(1000,     C_TRUE,     5,      0) == PM_RET_EX_VAL);
00448 
00449     // An exception should be thrown for an invalid frequency
00450     //                         u32_freq, b_isTimer2, u16_oc, i16_ocPin)
00451     CuAssertTrue(tc, configPwm(0,        C_TRUE,     1,      0) == PM_RET_EX_VAL);
00452 #if (FCY > 34000000L)
00453     // A min FCY given above gives a min frequnecy of 2 Hz, so we can test 1 Hz for failure.
00454     //                         u32_freq, b_isTimer2, u16_oc, i16_ocPin)
00455     CuAssertTrue(tc, configPwm(FCY/256L/65536L - 1L, C_TRUE,     1,      0) == PM_RET_EX_VAL);
00456 #endif
00457     //                         u32_freq, b_isTimer2, u16_oc, i16_ocPin)
00458     CuAssertTrue(tc, configPwm(FCY + 1L, C_TRUE,     1,      0) == PM_RET_EX_VAL);    
00459 
00460     // Configure and check bits
00461     //                         u32_freq, b_isTimer2, u16_oc, i16_ocPin)
00462     CuAssertTrue(tc, configPwm(1000,     C_TRUE,     2,      0) == PM_RET_OK);
00463     CuAssertTrue(tc, OC2CON == (OC_TIMER2_SRC | OC_PWM_FAULT_PIN_DISABLE));
00464 #if (FCY == 1000000L)
00465     CuAssertTrue(tc, T2CON == (T2_ON | T2_IDLE_CON | T2_GATE_OFF
00466           | T2_32BIT_MODE_OFF | T2_SOURCE_INT | T2_PS_1_1));
00467     CuAssertTrue(tc, PR2 == 999);
00468 #endif
00469     CuAssertTrue(tc, _RP0R == OUT_FN_PPS_OC2);
00470     CuAssertTrue(tc, OC2RS == 0);
00471     CuAssertTrue(tc, _TRISB0 == 0);
00472     CuAssertTrue(tc, _PCFG2 == 1);
00473     CuAssertTrue(tc, _CN4PUE == 0);
00474 }
00475 
00479 void
00480 test_setPwm(CuTest* tc)
00481 {
00482     //                            OCnRS OC
00483     CuAssertTrue(tc, setPwmCounts(600,  2) == PM_RET_OK);
00484     CuAssertTrue(tc, OC2RS == 600);
00485 }
00486 
00490 CuSuite*
00491 getSuite_testGpio() {
00492     CuSuite* suite = CuSuiteNew();
00493     SUITE_ADD_TEST(suite, test_gpioExists);
00494     SUITE_ADD_TEST(suite, test_gpioOdExists);
00495     SUITE_ADD_TEST(suite, test_gpioSetPinIsInput);
00496     SUITE_ADD_TEST(suite, test_gpioGetPinIsInput);
00497     SUITE_ADD_TEST(suite, test_gpioSetPinIsDigital);
00498     SUITE_ADD_TEST(suite, test_gpioSetPinIsOpenDrain);
00499     SUITE_ADD_TEST(suite, test_gpioSetPinPullDirection);
00500     SUITE_ADD_TEST(suite, test_gpioUnmapPin);
00501     SUITE_ADD_TEST(suite, test_gpioSetDigitalPin);
00502     SUITE_ADD_TEST(suite, test_gpioReadDigitalPin);
00503     SUITE_ADD_TEST(suite, test_gpioReadDigitalLatch);
00504     SUITE_ADD_TEST(suite, test_configDigitalPin);
00505     SUITE_ADD_TEST(suite, test_configAnalogPin);
00506     SUITE_ADD_TEST(suite, test_configPwm);
00507     SUITE_ADD_TEST(suite, test_setPwm);
00508     return suite;
00509 }
00510 
00511 
00512 int main(void)
00513 {
00514     CuString* output = CuStringNew();
00515     CuSuite*  suite = CuSuiteNew();
00516 
00517     // Add all suites to be tested
00518     CuSuiteAddSuite(suite, getSuite_testGpio());
00519 
00520     // Run the tests and report the results
00521     CuSuiteRun(suite);
00522     CuSuiteSummary(suite, output);
00523     CuSuiteDetails(suite, output);
00524     puts(output->buffer);
00525 
00526     /*
00527      * Zero failures indicates an all-good exit code.
00528      * Any errors gives a non-zero exit code that should stop the build
00529      * when this is called by the Makefile
00530      */
00531     return suite->failCount;
00532 }

Generated on Mon Oct 18 07:40:47 2010 for Python-on-a-chip by  doxygen 1.5.9