void test_write_overflow_16(void){
    uint16_t dataIn[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    uint16_t dataOut[BUFFER_ARRAY_LENGTH] = {0};
    
    uint16_t bufferArray[BUFFER_ARRAY_LENGTH] = {0};
    Buffer b;
    BufferStatus status;
    uint16_t data;
    
    status = BUF_init(&b, bufferArray, BUFFER_ARRAY_LENGTH, 16);
    
    int i;
    for(i = 0; i < 10; i++){
        status = BUF_write16(&b, dataIn[i]);
    }
    
    for(i = 0; i < BUFFER_ARRAY_LENGTH; i++){
        dataOut[i] = BUF_read16(&b);
    }
    
    /* test each element of the array */
    for(i = 0; i < BUFFER_ARRAY_LENGTH; i++){
        TEST_ASSERT_EQUAL_INT(i, dataOut[i]);
    }
}
void test_write3_read3_16(void){
    uint16_t dataIn[3] = {1,2,3};
    uint16_t dataOut[BUFFER_ARRAY_LENGTH] = {0};
    
    uint16_t bufferArray[BUFFER_ARRAY_LENGTH] = {0};
    Buffer b;
    BufferStatus status;
    uint16_t data;
    
    status = BUF_init(&b, bufferArray, BUFFER_ARRAY_LENGTH, 16);
    
    int i;
    for(i = 0; i < 3; i++){
        status = BUF_write16(&b, dataIn[i]);
    }
    
    for(i = 0; i < 3; i++){
        dataOut[i] = BUF_read16(&b);
    }
    
    /* test each element of the array */
    for(i = 0; i < 3; i++){
        TEST_ASSERT_EQUAL_INT(dataIn[i], dataOut[i]);
    }
}
void test_init_16(void)
{
    uint16_t bufferArray[BUFFER_ARRAY_LENGTH] = {0};
    Buffer b;
    BufferStatus status;
    
    status = BUF_init(&b, bufferArray, BUFFER_ARRAY_LENGTH, 16);
    
	TEST_ASSERT_EQUAL_INT(BUFFER_EMPTY, status);
}
void test_read_empty_16(void){
    uint16_t bufferArray[BUFFER_ARRAY_LENGTH] = {0};
    Buffer b;
    BufferStatus status;
    
    status = BUF_init(&b, bufferArray, BUFFER_ARRAY_LENGTH, 16);
    
    uint16_t data = 100;
    data = BUF_read16(&b);
    
	TEST_ASSERT_EQUAL_INT(0, data);
}
Esempio n. 5
0
void UART_init(void){
    ANSBbits.ANSB2 = ANSBbits.ANSB7 = 0;
    
    BUF_init((Buffer*)&txBuf, (uint8_t*)txBufArr, TX_BUF_LENGTH, BUF_WIDTH_IN_BITS);
    BUF_init((Buffer*)&rxBuf, (uint8_t*)rxBufArr, RX_BUF_LENGTH, BUF_WIDTH_IN_BITS);
    
    /* baud rate = 57600bps 
     * U1BRG = (12000000/(16*57600)) - 1 = 12.02 = 12
     */
    U1BRG = 12;
    U1MODE = 0x0000;    /* TX/RX only, standard mode */
    U1STA = 0x0000;     /* enable */
    
    /* uart interrupts */
    IFS0bits.U1TXIF = IFS0bits.U1RXIF = 0;
    IEC0bits.U1TXIE = IEC0bits.U1RXIE = 1;
    
    U1MODEbits.UARTEN = 1;
    U1STAbits.UTXEN = 1;
    
    return;
}
Esempio n. 6
0
void USBASP_init(void)
{
  uchar    i;
//Reconnect USB
  usbDeviceDisconnect();  /* enforce re-enumeration, do this while interrupts are disabled! */
  i = 0;
  while(--i)
     _delay_ms(2);
  usbDeviceConnect();
  usbInit();
  sei();
  BUF_init(&debug_buffer,debug_buffer_data,sizeof(debug_buffer_data));
}
void test_write_to_full_16(void){
    uint16_t bufferArray[BUFFER_ARRAY_LENGTH] = {0};
    Buffer b;
    BufferStatus status;
    
    status = BUF_init(&b, bufferArray, BUFFER_ARRAY_LENGTH, 16);
    
    int i;
    for(i = 0; i < BUFFER_ARRAY_LENGTH; i++){
        status = BUF_write16(&b, 1);
    }
    
	TEST_ASSERT_EQUAL_INT(BUFFER_FULL, status);
}
void test_write_to_full_read_to_empty_16(void){
    uint16_t bufferArray[BUFFER_ARRAY_LENGTH] = {0};
    Buffer b;
    BufferStatus status;
    uint16_t data;
    
    status = BUF_init(&b, bufferArray, BUFFER_ARRAY_LENGTH, 16);
    
    int i;
    for(i = 0; i < BUFFER_ARRAY_LENGTH; i++){
        status = BUF_write16(&b, 1);
    }
    
    for(i = 0; i < BUFFER_ARRAY_LENGTH; i++){
        data = BUF_read16(&b);
    }
    
    status = BUF_status(&b);
    
	TEST_ASSERT_EQUAL_INT(BUFFER_EMPTY, status);
}
Esempio n. 9
0
int main(void) {
    uint8_t i;
    BUF_init(&b, dataArr, ARR_LEN, ARR_WIDTH);
    showStatus();
    
    uint8_t values0[4] = {10,9,8,7};
    uint8_t values1[4] = {0,0,0,0};
    
    /* write 4 values to the buffer */
    printf("filling 4 element array\n");
    for(i = 0; i < 4; i++){
        BUF_write8(&b, values0[i]);
        showStatus();
    }
    
    /* read 4 values from the buffer values */
    printf("reading 4 element array\n");
    for(i=0; i < 4; i++){
        values1[i] = BUF_read8(&b);
        showStatus();
    }
    
    /* test for array equality */
    for(i=0; i < 4; i++){
        if(values0[i] != values1[i])
            while(1);
    }
    
    printf("4 element array comparison passed\n");
    
    uint8_t values2[] = {125,124,123,122,121,120,119,118};
    uint8_t values3[8] = {0};
    
    /* write 8 values to the buffer */
    printf("filling 8 element array\n");
    for(i = 0; i < 8; i++){
        BUF_write8(&b, values2[i]);
        showStatus();
    }
    
    /* attempt to write another 4 values */
    printf("attempting extra writes,  8 element array\n");
    for(i = 0; i < 4; i++){
        BUF_write8(&b, 100);
        showStatus();
    }
    
    /* read 8 values from the buffer values */
    printf("reading 8 element array\n");
    for(i=0; i < 8; i++){
        values3[i] = BUF_read8(&b);
        showStatus();
    }
    
    /* test for array equality */
    printf("comparing 8 element arrays\n");
    for(i=0; i < 8; i++){
        if(values2[i] != values3[i])
            while(1);
    }
    
    printf("8 element array comparison passed\n");

    return 0;
}