void writeTime(TimeValue &ts)
{
byte* vars[] = {&(ts.second), &(ts.minute), &(ts.hour), &(ts.dow), &(ts.day), &(ts.month), &(ts.year), &(ts.century)};
int addrs[] = {RTC_SECOND, RTC_MINUTE, RTC_HOUR, RTC_DOW,
RTC_DAY, RTC_MONTH, RTC_YEAR, RTC_CENTURY};
byte i;
dirI2CMux0(true);
setAddr(RTC_ADDR2, RTC_ADDR1, RTC_CENTURY);
i = readI2CMux();
dirI2CMux0(false);
writeI2CMux0(i | 0x80); // set write flag
digitalWrite(WE, 0);
delayMicroseconds(1);
digitalWrite(WE, 1);
for(i=0; i<8; i++){
setAddr(RTC_ADDR2, RTC_ADDR1, addrs[i]);
delayMicroseconds(I2CREADDELAYUS);
writeI2CMux0(*(vars[i]));
digitalWrite(WE, 0);
delayMicroseconds(1);
digitalWrite(WE, 1);
}
// write flag is reset by the century write which is the last one
dirI2CMux0(true);
}
AlarmValue readAlarm(uint8_t alidx)
{
AlarmValue v;
uint8_t dow_en;
dirI2CMux0(true);
alidx &= ALARM_MASK;
v.id = alidx;
// DOW + EN bits
setAddr(ALARM_ADDR2, ALARM_ADDR1, ALARM_ADDR0 + ALARM_DOW + (alidx << ALARM_NEXT_SHIFT));
dow_en = readI2CMux();
v.en = dow_en & 0x1;
v.dow = dow_en >> 1;
// Hour
setAddr(ALARM_ADDR2, ALARM_ADDR1, ALARM_ADDR0 + ALARM_HOUR + (alidx << ALARM_NEXT_SHIFT));
v.hour = readI2CMux();
// Minute
setAddr(ALARM_ADDR2, ALARM_ADDR1, ALARM_ADDR0 + ALARM_MINUTE + (alidx << ALARM_NEXT_SHIFT));
v.minute = readI2CMux();
// Flags
setAddr(ALARM_ADDR2, ALARM_ADDR1, ALARM_ADDR0 + ALARM_FLAGS + (alidx << ALARM_NEXT_SHIFT));
v.flags = readI2CMux() & 0b111;
return v;
}
void clearBank(unsigned char bank) {
setAddr(0, bank);
int c = 0;
while(c < PCD8544_HPIXELS) {
writeToLCD(LCD5110_DATA, 0);
c++;
}
setAddr(0, bank);
}
void clearLCD() {
setAddr(0, 0);
int c = 0;
while(c < PCD8544_MAXBYTES) {
writeToLCD(LCD5110_DATA, 0);
c++;
}
setAddr(0, 0);
}
uint8_t USB::DefaultAddressing(uint8_t parent, uint8_t port, bool lowspeed) {
//uint8_t buf[12];
uint8_t rcode;
UsbDevice *p0 = NULL, *p = NULL;
// Get pointer to pseudo device with address 0 assigned
p0 = addrPool.GetUsbDevicePtr(0);
if (!p0) return USB_ERROR_ADDRESS_NOT_FOUND_IN_POOL;
if (!p0->epinfo) return USB_ERROR_EPINFO_IS_NULL;
p0->lowspeed = lowspeed;
// Allocate new address according to device class
uint8_t bAddress = addrPool.AllocAddress(parent, false, port);
if (!bAddress) return USB_ERROR_OUT_OF_ADDRESS_SPACE_IN_POOL;
p = addrPool.GetUsbDevicePtr(bAddress);
if (!p) return USB_ERROR_ADDRESS_NOT_FOUND_IN_POOL;
p->lowspeed = lowspeed;
// Assign new address to the device
rcode = setAddr(0, 0, bAddress);
if (rcode) {
addrPool.FreeAddress(bAddress);
bAddress = 0;
}
return rcode;
}
// mode 0 - normal
// mode 1 - force refresh
// mode 2 - 1 + onelined
// mode 3 - 1 + month, year and century
TimeValue readTime(bool fullmode)
{
static TimeValue ts;
byte* vars[] = {&(ts.second), &(ts.minute), &(ts.hour), &(ts.dow), &(ts.day), &(ts.month), &(ts.year), &(ts.century)};
int addrs[] = {RTC_SECOND, RTC_MINUTE, RTC_HOUR, RTC_DOW,
RTC_DAY, RTC_MONTH, RTC_YEAR, RTC_CENTURY};
byte i;
int val;
dirI2CMux0(true);
for(i=0; i<8; i++){
setAddr(RTC_ADDR2, RTC_ADDR1, addrs[i]);
delayMicroseconds(I2CREADDELAYUS);
val = readI2CMux();
if(!fullmode && *(vars[i]) == val) break;
else *(vars[i]) = val;
}
ts.second = ts.second & 0x7F;
ts.century = ts.century & 0x3F;
ts.dow = ts.dow & 0x7;
return ts;
}
void drawChar(uint8_t x, uint8_t y, char c) {
uint8_t col = 0;
uint8_t row = 0;
uint8_t bit = 0x01;
uint8_t oc = c - 0x20;
setAddr(x, y, x + 4, y + 7); // if you want to fill column between chars, change x + 4 to x + 5
while (row < 8) {
while (col < 5) {
if (font[oc][col] & bit) {
//foreground
lcd_data_send(colorHighByte);
lcd_data_send(colorLowByte);
} else {
//background
lcd_data_send(bgColorHighByte);
lcd_data_send(bgColorLowByte);
}
col++;
}
// if you want to fill column between chars, writeData(bgColor) here
col = 0;
bit <<= 1;
row++;
}
}
void drawChar8x12(uint8_t x, uint8_t y, char c) {
uint8_t col = 0;
uint8_t row = 0;
uint8_t bit = 0x80;
uint8_t oc = c - 0x20;
setAddr(x, y, x + 7, y + 11);
while (row < 12) {
while (col < 8) {
if (font_8x12[oc][row] & bit) {
//foreground
lcd_data_send(colorHighByte);
lcd_data_send(colorLowByte);
} else {
//background
lcd_data_send(bgColorHighByte);
lcd_data_send(bgColorLowByte);
}
bit >>= 1;
col++;
}
bit = 0x80;
col = 0;
row++;
}
}
INETSockAddr::INETSockAddr (const char* hostname, int port)
{
TRACE_CALL;
(void) ::memset (addr_in(), 0, size ());
sin_port = htons (port);
setAddr (hostname); // sets sin_family
}
void Inet6AddressHolder::init(QByteArray addr, int scope_id) {
setAddr(addr);
if (scope_id >= 0) {
this->scope_id = scope_id;
this->scope_id_set = true;
}
}
int main() {
ROM_SysCtlPeripheralEnable(SPI_LED_SYSCTL);
ROM_GPIOPinTypeGPIOOutput(SPI_LED_BASE, SPI_LED_ERROR|SPI_LED_BUSY);
clockFreq = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
ROM_SysCtlPeripheralEnable(COCO_CS_SYSCTL);
ROM_GPIOPinTypeGPIOOutput(COCO_CS_BASE, COCO_CS);
ROM_GPIOPinWrite(COCO_CS_BASE, COCO_CS, COCO_CS);
uart_init(clockFreq);
disk_initialize(0);
ROM_GPIOPinWrite(SPI_LED_BASE, SPI_LED_ERROR|SPI_LED_BUSY, SPI_LED_BUSY);
if ((res = f_mount(0, &fatfs_obj))) {
ROM_GPIOPinWrite(SPI_LED_BASE, SPI_LED_ERROR|SPI_LED_BUSY, SPI_LED_ERROR);
UART_printstr("Mount failed!\r\n");
while (1);
}
setAddr(0x413000);
for (int i=0; i < 4*128; i++)
setData(f88[i]);
setAddr(0x420000);
if ((res = f_open(&fil_obj, "/dod.rom", FA_READ)) != FR_OK) {
ROM_GPIOPinWrite(SPI_LED_BASE, SPI_LED_ERROR|SPI_LED_BUSY, SPI_LED_ERROR);
UART_printstr("Can't open test file.\r\n");
while (1);
}
programRom(&fil_obj);
f_close(&fil_obj);
ROM_GPIOPinWrite(SPI_LED_BASE, SPI_LED_ERROR|SPI_LED_BUSY, 0);
while (1);
}
void GotoStatement::adjustFixedDest(int delta)
{
// Ensure that the destination is fixed.
if (!m_dest || !m_dest->isIntConst()) {
LOG_ERROR("Can't adjust destination of non-static CTI");
return;
}
auto theConst = std::static_pointer_cast<Const>(m_dest);
theConst->setAddr(theConst->getAddr() + delta);
}
void BroadcastNetwork::init() {
Mirf.init();
setAddr(myaddr);
setCRC2bytes(true);
Mirf.setRADDR((byte*)"bcast");
Mirf.setTADDR((byte*)"bcast");
// don't auto ack
// setConfigBits(EN_AA, _BV(ENAA_P1), 0);
Mirf.payload = sizeof(AodvPacket);
Mirf.config();
}
bool CNetClient::connect(const char * address, const int port)
{
setAddr(address, port);
int result = ::connect(_sock, (struct sockaddr *)&_addr, sizeof(_addr));
if(result < 0) {
throw NetException("Client Connect Error");
}
_connected = true;
return true;
}
void Inet6AddressHolder::init(QByteArray addr, QNetworkInterface nif)
throw (UnknownHostException)
{
setAddr(addr);
if (nif.isValid()) {
this->scope_id = nif.index();//deriveNumericScope(ipaddress, nif);
this->scope_id_set = true;
this->scope_ifname = nif;
this->scope_ifname_set = true;
}
}
void TFT_ILI9163C::drawPixel(int16_t x, int16_t y, uint16_t color) {
if (boundaryCheck(x,y)) return;
if ((x < 0) || (y < 0)) return;
setAddr(x,y,x+1,y+1);
#if defined(__MK20DX128__) || defined(__MK20DX256__)
writedata16_last(color);
endProc();
#else
writedata16(color);
#endif
}
//corrected!
void TFT_ILI9163C::clearScreen(uint16_t color) {
int px;
#if defined(__MK20DX128__) || defined(__MK20DX256__)
//SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
setAddr(0x00,0x00,_GRAMWIDTH,_GRAMHEIGH);//go home
//writecommand_cont(CMD_RAMWR);//this was missed!
for (px = 0;px < _GRAMSIZE; px++){
writedata16_cont(color);
}
_setAddrWindow(0x00,0x00,_GRAMWIDTH,_GRAMHEIGH);//go home
writecommand_last(CMD_NOP);
endProc();
#else
setAddr(0x00,0x00,_GRAMWIDTH,_GRAMHEIGH);//go home
//writecommand(CMD_RAMWR);
for (px = 0;px < _GRAMSIZE; px++){
writedata16(color);
}
#endif
}
unsigned char isThereTemperatureReady()
{
if(waitNRF()==0)
{
getTemp();
setAddr(17, 2);
showTemp();
NRF_down();
return 1;
};
return 0;
};
void main(void) {
init();
while(1) // main loop
{
/* if (btn_pressed)
{
if (btn_pressed==BTN_BACK) LCDoff();
if (btn_pressed==BTN_OK) LCDon();
if (btn_pressed==BTN_UP) backlightOn();
if (btn_pressed==BTN_DOWN) backlightOff();
btn_pressed=0;
};
*/
defaultRX = 1;
NRF_init(85);
while(!isThereTemperatureReady())
{
setAddr(17, 0);
showTime();
delay_sec(1);
};
defaultRX = 0;
NRF_init(86);
TXBuf[0] = 0x10;
TXBuf[1] = 0xff;
TXBuf[2] = RXBuf[2];
TXBuf[3] = RXBuf[3];
TXBuf[4] = RXBuf[4];
NRF_transmit(5);
NRF_down();
char i;
for (i=0; i<9; i++)
{
delay_sec(60);
};
delay_sec(30);
};
}
void writeAlarm(uint8_t alidx, AlarmValue &v)
{
dirI2CMux0(false);
// DOW + EN bits
setAddr(ALARM_ADDR2, ALARM_ADDR1, ALARM_ADDR0 + ALARM_DOW + (alidx << ALARM_NEXT_SHIFT));
writeI2CData(I2CDATA, I2CRTC, (v.dow << 1) + v.en);
digitalWrite(WE, 0);
delayMicroseconds(I2CWRITEDELAYUS);
digitalWrite(WE, 1);
// Hour
setAddr(ALARM_ADDR2, ALARM_ADDR1, ALARM_ADDR0 + ALARM_HOUR + (alidx << ALARM_NEXT_SHIFT));
writeI2CData(I2CDATA, I2CRTC, v.hour);
digitalWrite(WE, 0);
delayMicroseconds(I2CWRITEDELAYUS);
digitalWrite(WE, 1);
// Minute
setAddr(ALARM_ADDR2, ALARM_ADDR1, ALARM_ADDR0 + ALARM_MINUTE + (alidx << ALARM_NEXT_SHIFT));
writeI2CData(I2CDATA, I2CRTC, v.minute);
digitalWrite(WE, 0);
delayMicroseconds(I2CWRITEDELAYUS);
digitalWrite(WE, 1);
// Flags
setAddr(ALARM_ADDR2, ALARM_ADDR1, ALARM_ADDR0 + ALARM_FLAGS + (alidx << ALARM_NEXT_SHIFT));
writeI2CData(I2CDATA, I2CRTC, v.flags);
digitalWrite(WE, 0);
delayMicroseconds(I2CWRITEDELAYUS);
digitalWrite(WE, 1);
}
int CNetServer::bind(const char * address, const int port)
{
if(!isValid()) {
throw NetException("Server Socket error");
}
setAddr(address, port);
int result = ::bind(_sock, (struct sockaddr *) & _addr, sizeof(_addr));
if(result < 0) {
throw NetException("Server Bind error");
}
return 0;
}
void TFT_ILI9163C::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) {
// Rudimentary clipping
if (boundaryCheck(x,y)) return;
if (((y + h) - 1) >= _height) h = _height-y;
setAddr(x,y,x,(y+h)-1);
while (h-- > 1) {
#if defined(__MK20DX128__) || defined(__MK20DX256__)
if (h == 0){
writedata16_last(color);
} else {
writedata16_cont(color);
}
#else
writedata16(color);
#endif
}
endProc();
}
void TFT_ILI9163C::drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) {
// Rudimentary clipping
if (boundaryCheck(x,y)) return;
if (((x+w) - 1) >= _width) w = _width-x;
setAddr(x,y,(x+w)-1,y);
while (w-- > 1) {
#if defined(__MK20DX128__) || defined(__MK20DX256__)
if (w == 0){
writedata16_last(color);
} else {
writedata16_cont(color);
}
#else
writedata16(color);
#endif
}
endProc();
}
// fill a rectangle
void TFT_ILI9163C::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {
if (boundaryCheck(x,y)) return;
if (((x + w) - 1) >= _width) w = _width - x;
if (((y + h) - 1) >= _height) h = _height - y;
setAddr(x,y,(x+w)-1,(y+h)-1);
for (y = h;y > 0;y--) {
for (x = w;x > 1;x--) {
#if defined(__MK20DX128__) || defined(__MK20DX256__)
writedata16_cont(color);
#else
writedata16(color);
#endif
}
#if defined(__MK20DX128__) || defined(__MK20DX256__)
writedata16_last(color);
#endif
}
endProc();
}
void drawChar(uint8_t x, uint8_t y, char c) {
uint8_t col = 0;
uint8_t row = 0;
uint8_t bit = 0x01;
uint8_t oc = c - 0x20;
setAddr(x, y, x + 4, y + 7);
while (row < 8) {
while (col < 5) {
if (font[oc][col] & bit) {
lcd_data_send(colorHighByte);
lcd_data_send(colorLowByte);
} else {
lcd_data_send(bgColorHighByte);
lcd_data_send(bgColorLowByte);
}
col++;
}
col = 0;
bit <<= 1;
row++;
}
}
void main(void) {
WDTCTL = WDTPW + WDTHOLD; // disable WDT
BCSCTL1 = CALBC1_1MHZ; // 1MHz clock
DCOCTL = CALDCO_1MHZ;
P1OUT |= LCD5110_SCE_PIN + LCD5110_DC_PIN;
P1DIR |= LCD5110_SCE_PIN + LCD5110_DC_PIN;
// setup USIB
P1SEL |= LCD5110_SCLK_PIN + LCD5110_DN_PIN;
P1SEL2 |= LCD5110_SCLK_PIN + LCD5110_DN_PIN;
UCB0CTL0 |= UCCKPH + UCMSB + UCMST + UCSYNC; // 3-pin, 8-bit SPI master
UCB0CTL1 |= UCSSEL_2; // SMCLK
UCB0BR0 |= 0x01; // 1:1
UCB0BR1 = 0;
UCB0CTL1 &= ~UCSWRST; // clear SW
_delay_cycles(500000);
initLCD();
clearLCD();
// LCD test
writeStringToLCD("Nokia 5110");
_delay_cycles(2000000);
setAddr(0, 0);
int c = 0x20;
while(c < (65 + 0x20)) {
writeCharToLCD(c);
c++;
}
_delay_cycles(2000000);
clearLCD();
c = 65 + 0x20;
while(c < (96 + 0x20)) {
writeCharToLCD(c);
c++;
}
_delay_cycles(2000000);
c = 0;
clearBank(3);
while(c < 64) {
writeToLCD(LCD5110_DATA, 0xFF);
c++;
_delay_cycles(20000);
}
clearBank(4);
while(c < 100) {
writeToLCD(LCD5110_DATA, 0xFF);
c++;
_delay_cycles(20000);
}
clearBank(5);
while(c < 184) {
writeToLCD(LCD5110_DATA, 0xFF);
c++;
_delay_cycles(20000);
}
_delay_cycles(2000000);
clearBank(3);
writeGraphicToLCD(testBlock, NONE);
writeGraphicToLCD(testBlock, FLIP_V);
writeGraphicToLCD(testBlock, FLIP_H);
writeGraphicToLCD(testBlock, ROTATE);
writeGraphicToLCD(testBlock, FLIP_V | ROTATE);
writeGraphicToLCD(testBlock, FLIP_H | ROTATE);
writeGraphicToLCD(testBlock, ROTATE_90_CCW);
writeGraphicToLCD(testBlock, ROTATE_180);
clearBank(4);
writeGraphicToLCD(testBlock2, NONE);
writeGraphicToLCD(testBlock2, FLIP_H);
writeGraphicToLCD(testBlock2, ROTATE);
writeGraphicToLCD(testBlock2, ROTATE_90_CCW);
clearBank(0);
writeStringToLCD("For details,");
clearBank(1);
writeStringToLCD("visit 43oh.com");
clearBank(2);
}
/* USB main task. Performs enumeration/cleanup */
void USB::Task( void ) //USB state machine
{
byte i;
byte rcode;
static byte tmpaddr;
byte tmpdata;
static unsigned long delay = 0;
USB_DEVICE_DESCRIPTOR buf;
tmpdata = getVbusState();
/* modify USB task state if Vbus changed */
switch( tmpdata ) {
case SE1: //illegal state
usb_task_state = USB_DETACHED_SUBSTATE_ILLEGAL;
break;
case SE0: //disconnected
if(( usb_task_state & USB_STATE_MASK ) != USB_STATE_DETACHED ) {
usb_task_state = USB_DETACHED_SUBSTATE_INITIALIZE;
}
break;
case FSHOST: //attached
case LSHOST:
if(( usb_task_state & USB_STATE_MASK ) == USB_STATE_DETACHED ) {
delay = millis() + USB_SETTLE_DELAY;
usb_task_state = USB_ATTACHED_SUBSTATE_SETTLE;
}
break;
}// switch( tmpdata
//Serial.print("USB task state: ");
//Serial.println( usb_task_state, HEX );
switch( usb_task_state ) {
case USB_DETACHED_SUBSTATE_INITIALIZE:
init();
usb_task_state = USB_DETACHED_SUBSTATE_WAIT_FOR_DEVICE;
break;
case USB_DETACHED_SUBSTATE_WAIT_FOR_DEVICE: //just sit here
break;
case USB_DETACHED_SUBSTATE_ILLEGAL: //just sit here
break;
case USB_ATTACHED_SUBSTATE_SETTLE: //setlle time for just attached device
if( delay < millis() ) {
usb_task_state = USB_ATTACHED_SUBSTATE_RESET_DEVICE;
}
break;
case USB_ATTACHED_SUBSTATE_RESET_DEVICE:
regWr( rHCTL, bmBUSRST ); //issue bus reset
usb_task_state = USB_ATTACHED_SUBSTATE_WAIT_RESET_COMPLETE;
break;
case USB_ATTACHED_SUBSTATE_WAIT_RESET_COMPLETE:
if(( regRd( rHCTL ) & bmBUSRST ) == 0 ) {
tmpdata = regRd( rMODE ) | bmSOFKAENAB; //start SOF generation
regWr( rMODE, tmpdata );
// regWr( rMODE, bmSOFKAENAB );
usb_task_state = USB_ATTACHED_SUBSTATE_WAIT_SOF;
delay = millis() + 20; //20ms wait after reset per USB spec
}
break;
case USB_ATTACHED_SUBSTATE_WAIT_SOF: //todo: change check order
if( regRd( rHIRQ ) & bmFRAMEIRQ ) { //when first SOF received we can continue
if( delay < millis() ) { //20ms passed
usb_task_state = USB_ATTACHED_SUBSTATE_GET_DEVICE_DESCRIPTOR_SIZE;
}
}
break;
case USB_ATTACHED_SUBSTATE_GET_DEVICE_DESCRIPTOR_SIZE:
// toggle( BPNT_0 );
devtable[ 0 ].epinfo->MaxPktSize = 8; //set max.packet size to min.allowed
rcode = getDevDescr( 0, 0, 8, ( char* )&buf );
if( rcode == 0 ) {
devtable[ 0 ].epinfo->MaxPktSize = buf.bMaxPacketSize0;
usb_task_state = USB_STATE_ADDRESSING;
}
else {
usb_error = USB_ATTACHED_SUBSTATE_GET_DEVICE_DESCRIPTOR_SIZE;
usb_task_state = USB_STATE_ERROR;
}
break;
case USB_STATE_ADDRESSING:
for( i = 1; i < USB_NUMDEVICES; i++ ) {
if( devtable[ i ].epinfo == NULL ) {
devtable[ i ].epinfo = devtable[ 0 ].epinfo; //set correct MaxPktSize
//temporary record
//until plugged with real device endpoint structure
rcode = setAddr( 0, 0, i );
if( rcode == 0 ) {
tmpaddr = i;
usb_task_state = USB_STATE_CONFIGURING;
}
else {
usb_error = USB_STATE_ADDRESSING; //set address error
usb_task_state = USB_STATE_ERROR;
}
break; //break if address assigned or error occured during address assignment attempt
}
}//for( i = 1; i < USB_NUMDEVICES; i++
if( usb_task_state == USB_STATE_ADDRESSING ) { //no vacant place in devtable
usb_error = 0xfe;
usb_task_state = USB_STATE_ERROR;
}
break;
case USB_STATE_CONFIGURING:
break;
case USB_STATE_RUNNING:
break;
case USB_STATE_ERROR:
break;
}// switch( usb_task_state
}
void TFT_ILI9163C::startPushData(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
setAddr(x0,y0,x1,y1);
}
CameraInfo::CameraInfo(const QString &name, const QString &driverType, const QString &addr)
{
setName(name);;
setDriverType(driverType);
setAddr(addr);
}
Temperature::Temperature()
{
setDeviceName("Temperature Sensor");
setDeviceType(SENSOR);
setAddr(ADC_BG_ADDRESS);
}
